pass


class CutSpec(typing.Sequence[str]):
    pass


class Data(typing.Sequence[typing.Sequence[typing.Union[str, bytes]]]):
    pass

            

Reported by Pylint.

                  pass


class CutSpec(typing.Sequence[str]):
    pass


class Data(typing.Sequence[typing.Sequence[typing.Union[str, bytes]]]):
    pass

            

Reported by Pylint.

                  def completion(self, manager: "CommandManager", t: type, s: str) -> typing.Sequence[str]:
        return ["false", "true"]

    def parse(self, manager: "CommandManager", t: type, s: str) -> bool:
        if s == "true":
            return True
        elif s == "false":
            return False
        else:

            

Reported by Pylint.

                  def completion(self, manager: "CommandManager", t: type, s: str) -> typing.Sequence[str]:
        return ["false", "true"]

    def parse(self, manager: "CommandManager", t: type, s: str) -> bool:
        if s == "true":
            return True
        elif s == "false":
            return False
        else:

            

Reported by Pylint.

                  def completion(self, manager: "CommandManager", t: type, s: str) -> typing.Sequence[str]:
        return []

    def parse(self, manager: "CommandManager", t: type, s: str) -> str:
        try:
            return self.escape_sequences.sub(self._unescape, s)
        except ValueError as e:
            raise exceptions.TypeError(f"Invalid str: {e}") from e


            

Reported by Pylint.

                  def completion(self, manager: "CommandManager", t: type, s: str) -> typing.Sequence[str]:
        return []

    def parse(self, manager: "CommandManager", t: type, s: str) -> str:
        try:
            return self.escape_sequences.sub(self._unescape, s)
        except ValueError as e:
            raise exceptions.TypeError(f"Invalid str: {e}") from e


            

Reported by Pylint.

                  def completion(self, manager: "CommandManager", t: type, s: str) -> typing.Sequence[str]:
        return []

    def parse(self, manager: "CommandManager", t: type, s: str) -> bytes:
        try:
            return strutils.escaped_str_to_bytes(s)
        except ValueError as e:
            raise exceptions.TypeError(str(e))


            

Reported by Pylint.

                  def completion(self, manager: "CommandManager", t: type, s: str) -> typing.Sequence[str]:
        return []

    def parse(self, manager: "CommandManager", t: type, s: str) -> bytes:
        try:
            return strutils.escaped_str_to_bytes(s)
        except ValueError as e:
            raise exceptions.TypeError(str(e))


            

Reported by Pylint.

                  def completion(self, manager: "CommandManager", t: type, s: str) -> typing.Sequence[str]:
        return []

    def parse(self, manager: "CommandManager", t: type, s: str) -> str:
        return s

    def is_valid(self, manager: "CommandManager", typ: typing.Any, val: typing.Any) -> bool:
        return False


            

Reported by Pylint.

                  def completion(self, manager: "CommandManager", t: type, s: str) -> typing.Sequence[str]:
        return []

    def parse(self, manager: "CommandManager", t: type, s: str) -> str:
        return s

    def is_valid(self, manager: "CommandManager", typ: typing.Any, val: typing.Any) -> bool:
        return False


            

Reported by Pylint.

                      return self.to_pem()

    def set_state(self, state):
        self._cert = x509.load_pem_x509_certificate(state)

    @classmethod
    def from_pem(cls, data: bytes) -> "Cert":
        cert = x509.load_pem_x509_certificate(data)  # type: ignore
        return cls(cert)

            

Reported by Pylint.

              
    @classmethod
    def from_pem(cls, data: bytes) -> "Cert":
        cert = x509.load_pem_x509_certificate(data)  # type: ignore
        return cls(cert)

    def to_pem(self) -> bytes:
        return self._cert.public_bytes(serialization.Encoding.PEM)


            

Reported by Pylint.

              ) -> Tuple[rsa.RSAPrivateKeyWithSerialization, x509.Certificate]:
    now = datetime.datetime.now()

    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=key_size,
    )  # type: ignore
    name = x509.Name([
        x509.NameAttribute(NameOID.COMMON_NAME, cn),

            

Reported by Pylint.

              
            # PKCS12 format for Windows devices
            (path / f"{basename}-ca.p12").write_bytes(
                pkcs12.serialize_key_and_certificates(  # type: ignore
                    name=basename.encode(),
                    key=key,
                    cert=ca,
                    cas=None,
                    encryption_algorithm=serialization.NoEncryption(),

            

Reported by Pylint.

              
        # Dump the certificate in PKCS12 format for Windows devices
        (path / f"{basename}-ca-cert.p12").write_bytes(
            pkcs12.serialize_key_and_certificates(
                name=basename.encode(),
                key=None,  # type: ignore
                cert=ca,
                cas=None,
                encryption_algorithm=serialization.NoEncryption(),

            

Reported by Pylint.

                  if the private key is unencrypted.
    """
    try:
        return serialization.load_pem_private_key(data, password)  # type: ignore
    except TypeError:
        if password is not None:
            return load_pem_private_key(data, None)
        raise

            

Reported by Pylint.

                      return self._cert.public_bytes(serialization.Encoding.PEM)

    @classmethod
    def from_pyopenssl(self, x509: OpenSSL.crypto.X509) -> "Cert":
        return Cert(x509.to_cryptography())

    def to_pyopenssl(self) -> OpenSSL.crypto.X509:
        return OpenSSL.crypto.X509.from_cryptography(self._cert)


            

Reported by Pylint.

              
        # we could use cryptography for this, but it's unclear how to convert cryptography's object to pyOpenSSL's
        # expected format.
        bio = OpenSSL.SSL._lib.BIO_new_file(str(path).encode(sys.getfilesystemencoding()), b"r")  # type: ignore
        if bio != OpenSSL.SSL._ffi.NULL:  # type: ignore
            bio = OpenSSL.SSL._ffi.gc(bio, OpenSSL.SSL._lib.BIO_free)  # type: ignore
            dh = OpenSSL.SSL._lib.PEM_read_bio_DHparams(  # type: ignore
                bio,
                OpenSSL.SSL._ffi.NULL,  # type: ignore

            

Reported by Pylint.

                      # we could use cryptography for this, but it's unclear how to convert cryptography's object to pyOpenSSL's
        # expected format.
        bio = OpenSSL.SSL._lib.BIO_new_file(str(path).encode(sys.getfilesystemencoding()), b"r")  # type: ignore
        if bio != OpenSSL.SSL._ffi.NULL:  # type: ignore
            bio = OpenSSL.SSL._ffi.gc(bio, OpenSSL.SSL._lib.BIO_free)  # type: ignore
            dh = OpenSSL.SSL._lib.PEM_read_bio_DHparams(  # type: ignore
                bio,
                OpenSSL.SSL._ffi.NULL,  # type: ignore
                OpenSSL.SSL._ffi.NULL,  # type: ignore

            

Reported by Pylint.

                      # expected format.
        bio = OpenSSL.SSL._lib.BIO_new_file(str(path).encode(sys.getfilesystemencoding()), b"r")  # type: ignore
        if bio != OpenSSL.SSL._ffi.NULL:  # type: ignore
            bio = OpenSSL.SSL._ffi.gc(bio, OpenSSL.SSL._lib.BIO_free)  # type: ignore
            dh = OpenSSL.SSL._lib.PEM_read_bio_DHparams(  # type: ignore
                bio,
                OpenSSL.SSL._ffi.NULL,  # type: ignore
                OpenSSL.SSL._ffi.NULL,  # type: ignore
                OpenSSL.SSL._ffi.NULL  # type: ignore

            

Reported by Pylint.

              import sys
import traceback

import pytest

from mitmproxy import addonmanager
from mitmproxy import exceptions
from mitmproxy.addons import script
from mitmproxy.proxy.layers.http import HttpRequestHook

            

Reported by Pylint.

                          await tctx.master.await_log("Loading")

            tctx.master.clear()
            for i in range(20):
                f.write("\n")
                if tctx.master.has_log("Loading"):
                    break
                await asyncio.sleep(0.1)
            else:

            

Reported by Pylint.

              import asyncio
import os
import sys
import traceback

import pytest

from mitmproxy import addonmanager
from mitmproxy import exceptions

            

Reported by Pylint.

              

@pytest.mark.asyncio
async def test_load_script(tdata):
    with taddons.context() as tctx:
        ns = script.load_script(
            tdata.path(
                "mitmproxy/data/addonscripts/recorder/recorder.py"
            )

            

Reported by Pylint.

              @pytest.mark.asyncio
async def test_load_script(tdata):
    with taddons.context() as tctx:
        ns = script.load_script(
            tdata.path(
                "mitmproxy/data/addonscripts/recorder/recorder.py"
            )
        )
        assert ns.addons

            

Reported by Pylint.

                              "mitmproxy/data/addonscripts/recorder/recorder.py"
            )
        )
        assert ns.addons

        script.load_script(
            "nonexistent"
        )
        await tctx.master.await_log("No such file or directory")

            

Reported by Bandit.

                  This only succeeds if they get assigned different basenames.

    """
    ns = script.load_script(
        tdata.path(
            "mitmproxy/data/addonscripts/addon.py"
        )
    )
    assert ns.addons

            

Reported by Pylint.

                          "mitmproxy/data/addonscripts/addon.py"
        )
    )
    assert ns.addons
    ns2 = script.load_script(
        tdata.path(
            "mitmproxy/data/addonscripts/same_filename/addon.py"
        )
    )

            

Reported by Bandit.

                          "mitmproxy/data/addonscripts/same_filename/addon.py"
        )
    )
    assert ns.name != ns2.name
    assert not hasattr(ns2, "addons")


class TestScript:
    def test_notfound(self):

            

Reported by Bandit.

                      )
    )
    assert ns.name != ns2.name
    assert not hasattr(ns2, "addons")


class TestScript:
    def test_notfound(self):
        with taddons.context():

            

Reported by Bandit.

              from unittest import mock
from unittest.mock import MagicMock

import pytest

from mitmproxy.test import tflow
from mitmproxy.test import tutils
from mitmproxy.http import HTTPFlow


            

Reported by Pylint.

              
import pytest

from mitmproxy.test import tflow
from mitmproxy.test import tutils
from mitmproxy.http import HTTPFlow

from examples.contrib.webscanner_helper.proxyauth_selenium import logger, randomString, AuthorizationOracle, \
    SeleniumAddon

            

Reported by Pylint.

              import pytest

from mitmproxy.test import tflow
from mitmproxy.test import tutils
from mitmproxy.http import HTTPFlow

from examples.contrib.webscanner_helper.proxyauth_selenium import logger, randomString, AuthorizationOracle, \
    SeleniumAddon


            

Reported by Pylint.

              
from mitmproxy.test import tflow
from mitmproxy.test import tutils
from mitmproxy.http import HTTPFlow

from examples.contrib.webscanner_helper.proxyauth_selenium import logger, randomString, AuthorizationOracle, \
    SeleniumAddon



            

Reported by Pylint.

              from mitmproxy.test import tutils
from mitmproxy.http import HTTPFlow

from examples.contrib.webscanner_helper.proxyauth_selenium import logger, randomString, AuthorizationOracle, \
    SeleniumAddon


class TestRandomString:


            

Reported by Pylint.

              

class AuthenticationOracleTest(AuthorizationOracle):
    def is_unauthorized_request(self, flow: HTTPFlow) -> bool:
        return True

    def is_unauthorized_response(self, flow: HTTPFlow) -> bool:
        return True


            

Reported by Pylint.

                  def is_unauthorized_request(self, flow: HTTPFlow) -> bool:
        return True

    def is_unauthorized_response(self, flow: HTTPFlow) -> bool:
        return True


oracle = AuthenticationOracleTest()


            

Reported by Pylint.

              
class TestSeleniumAddon:

    def test_request_replay(self, selenium_addon):
        f = tflow.tflow(resp=tutils.tresp())
        f.request.is_replay = True
        with mock.patch.object(logger, 'warning') as mock_warning:
            selenium_addon.request(f)
        mock_warning.assert_called()

            

Reported by Pylint.

                          selenium_addon.request(f)
        mock_warning.assert_called()

    def test_request(self, selenium_addon):
        f = tflow.tflow(resp=tutils.tresp())
        f.request.url = "http://example.com/login.php"
        selenium_addon.set_cookies = False
        assert not selenium_addon.set_cookies
        with mock.patch.object(logger, 'debug') as mock_debug:

            

Reported by Pylint.

                      mock_debug.assert_called()
        assert selenium_addon.set_cookies

    def test_request_filtered(self, selenium_addon):
        f = tflow.tflow(resp=tutils.tresp())
        selenium_addon.set_cookies = False
        assert not selenium_addon.set_cookies
        selenium_addon.request(f)
        assert not selenium_addon.set_cookies

            

Reported by Pylint.

              import json
from unittest import mock

from mitmproxy import flowfilter
from mitmproxy.test import tflow
from mitmproxy.test import tutils

from examples.contrib.webscanner_helper.urlinjection import InjectionGenerator, HTMLInjection, RobotsInjection, \
    SitemapInjection, \

            

Reported by Pylint.

              from unittest import mock

from mitmproxy import flowfilter
from mitmproxy.test import tflow
from mitmproxy.test import tutils

from examples.contrib.webscanner_helper.urlinjection import InjectionGenerator, HTMLInjection, RobotsInjection, \
    SitemapInjection, \
    UrlInjectionAddon, logger

            

Reported by Pylint.

              
from mitmproxy import flowfilter
from mitmproxy.test import tflow
from mitmproxy.test import tutils

from examples.contrib.webscanner_helper.urlinjection import InjectionGenerator, HTMLInjection, RobotsInjection, \
    SitemapInjection, \
    UrlInjectionAddon, logger


            

Reported by Pylint.

              from mitmproxy.test import tflow
from mitmproxy.test import tutils

from examples.contrib.webscanner_helper.urlinjection import InjectionGenerator, HTMLInjection, RobotsInjection, \
    SitemapInjection, \
    UrlInjectionAddon, logger

index = json.loads(
    "{\"http://example.com:80\": {\"/\": {\"GET\": [301]}}, \"http://www.example.com:80\": {\"/test\": {\"POST\": [302]}}}")

            

Reported by Pylint.

                      tmpfile = tmpdir.join("tmpfile")
        with open(tmpfile, "w") as tfile:
            json.dump(index, tfile)
        flt = f"~u .*/site.html$"
        url_injection = UrlInjectionAddon(f"~u .*/site.html$", tmpfile, HTMLInjection(insert=True))
        assert "http://example.com:80" in url_injection.url_store
        fltr = flowfilter.parse(flt)
        f = tflow.tflow(resp=tutils.tresp())
        f.request.url = "http://example.com/site.html"

            

Reported by Pylint.

                      with open(tmpfile, "w") as tfile:
            json.dump(index, tfile)
        flt = f"~u .*/site.html$"
        url_injection = UrlInjectionAddon(f"~u .*/site.html$", tmpfile, HTMLInjection(insert=True))
        assert "http://example.com:80" in url_injection.url_store
        fltr = flowfilter.parse(flt)
        f = tflow.tflow(resp=tutils.tresp())
        f.request.url = "http://example.com/site.html"
        assert fltr(f)

            

Reported by Pylint.

              import json
from unittest import mock

from mitmproxy import flowfilter
from mitmproxy.test import tflow
from mitmproxy.test import tutils

from examples.contrib.webscanner_helper.urlinjection import InjectionGenerator, HTMLInjection, RobotsInjection, \
    SitemapInjection, \

            

Reported by Pylint.

              from mitmproxy.test import tflow
from mitmproxy.test import tutils

from examples.contrib.webscanner_helper.urlinjection import InjectionGenerator, HTMLInjection, RobotsInjection, \
    SitemapInjection, \
    UrlInjectionAddon, logger

index = json.loads(
    "{\"http://example.com:80\": {\"/\": {\"GET\": [301]}}, \"http://www.example.com:80\": {\"/test\": {\"POST\": [302]}}}")

            

Reported by Pylint.

                  UrlInjectionAddon, logger

index = json.loads(
    "{\"http://example.com:80\": {\"/\": {\"GET\": [301]}}, \"http://www.example.com:80\": {\"/test\": {\"POST\": [302]}}}")


class TestInjectionGenerator:

    def test_inject(self):

            

Reported by Pylint.

                  "{\"http://example.com:80\": {\"/\": {\"GET\": [301]}}, \"http://www.example.com:80\": {\"/test\": {\"POST\": [302]}}}")


class TestInjectionGenerator:

    def test_inject(self):
        f = tflow.tflow(resp=tutils.tresp())
        injection_generator = InjectionGenerator()
        injection_generator.inject(index=index, flow=f)

            

Reported by Pylint.

              import pytest

from mitmproxy.utils import strutils


def test_always_bytes():
    assert strutils.always_bytes(bytes(range(256))) == bytes(range(256))
    assert strutils.always_bytes("foo") == b"foo"
    with pytest.raises(ValueError):

            

Reported by Pylint.

              import pytest

from mitmproxy.utils import strutils


def test_always_bytes():
    assert strutils.always_bytes(bytes(range(256))) == bytes(range(256))
    assert strutils.always_bytes("foo") == b"foo"
    with pytest.raises(ValueError):

            

Reported by Pylint.

              from mitmproxy.utils import strutils


def test_always_bytes():
    assert strutils.always_bytes(bytes(range(256))) == bytes(range(256))
    assert strutils.always_bytes("foo") == b"foo"
    with pytest.raises(ValueError):
        strutils.always_bytes("\u2605", "ascii")
    with pytest.raises(TypeError):

            

Reported by Pylint.

              

def test_always_bytes():
    assert strutils.always_bytes(bytes(range(256))) == bytes(range(256))
    assert strutils.always_bytes("foo") == b"foo"
    with pytest.raises(ValueError):
        strutils.always_bytes("\u2605", "ascii")
    with pytest.raises(TypeError):
        strutils.always_bytes(42, "ascii")

            

Reported by Bandit.

              
def test_always_bytes():
    assert strutils.always_bytes(bytes(range(256))) == bytes(range(256))
    assert strutils.always_bytes("foo") == b"foo"
    with pytest.raises(ValueError):
        strutils.always_bytes("\u2605", "ascii")
    with pytest.raises(TypeError):
        strutils.always_bytes(42, "ascii")


            

Reported by Bandit.

                      strutils.always_bytes(42, "ascii")


def test_always_str():
    with pytest.raises(TypeError):
        strutils.always_str(42)
    assert strutils.always_str("foo") == "foo"
    assert strutils.always_str(b"foo") == "foo"
    assert strutils.always_str(None) is None

            

Reported by Pylint.

              def test_always_str():
    with pytest.raises(TypeError):
        strutils.always_str(42)
    assert strutils.always_str("foo") == "foo"
    assert strutils.always_str(b"foo") == "foo"
    assert strutils.always_str(None) is None


def test_escape_control_characters():

            

Reported by Bandit.

                  with pytest.raises(TypeError):
        strutils.always_str(42)
    assert strutils.always_str("foo") == "foo"
    assert strutils.always_str(b"foo") == "foo"
    assert strutils.always_str(None) is None


def test_escape_control_characters():
    assert strutils.escape_control_characters("one") == "one"

            

Reported by Bandit.

                      strutils.always_str(42)
    assert strutils.always_str("foo") == "foo"
    assert strutils.always_str(b"foo") == "foo"
    assert strutils.always_str(None) is None


def test_escape_control_characters():
    assert strutils.escape_control_characters("one") == "one"
    assert strutils.escape_control_characters("\00ne") == ".ne"

            

Reported by Bandit.

                  assert strutils.always_str(None) is None


def test_escape_control_characters():
    assert strutils.escape_control_characters("one") == "one"
    assert strutils.escape_control_characters("\00ne") == ".ne"
    assert strutils.escape_control_characters("\nne") == "\nne"
    assert strutils.escape_control_characters("\nne", False) == ".ne"
    assert strutils.escape_control_characters("\u2605") == "\u2605"

            

Reported by Pylint.

              import pytest

from mitmproxy.http import Headers
from mitmproxy.net.http.http1.read import (
    read_request_head,
    read_response_head, connection_close, expected_http_body_size,
    _read_request_line, _read_response_line, _read_headers, get_header_tokens
)
from mitmproxy.test.tutils import treq, tresp

            

Reported by Pylint.

              import pytest

from mitmproxy.http import Headers
from mitmproxy.net.http.http1.read import (
    read_request_head,
    read_response_head, connection_close, expected_http_body_size,
    _read_request_line, _read_response_line, _read_headers, get_header_tokens
)
from mitmproxy.test.tutils import treq, tresp

            

Reported by Pylint.

              from mitmproxy.test.tutils import treq, tresp


def test_get_header_tokens():
    headers = Headers()
    assert get_header_tokens(headers, "foo") == []
    headers["foo"] = "bar"
    assert get_header_tokens(headers, "foo") == ["bar"]
    headers["foo"] = "bar, voing"

            

Reported by Pylint.

              
def test_get_header_tokens():
    headers = Headers()
    assert get_header_tokens(headers, "foo") == []
    headers["foo"] = "bar"
    assert get_header_tokens(headers, "foo") == ["bar"]
    headers["foo"] = "bar, voing"
    assert get_header_tokens(headers, "foo") == ["bar", "voing"]
    headers.set_all("foo", ["bar, voing", "oink"])

            

Reported by Bandit.

                  headers = Headers()
    assert get_header_tokens(headers, "foo") == []
    headers["foo"] = "bar"
    assert get_header_tokens(headers, "foo") == ["bar"]
    headers["foo"] = "bar, voing"
    assert get_header_tokens(headers, "foo") == ["bar", "voing"]
    headers.set_all("foo", ["bar, voing", "oink"])
    assert get_header_tokens(headers, "foo") == ["bar", "voing", "oink"]


            

Reported by Bandit.

                  headers["foo"] = "bar"
    assert get_header_tokens(headers, "foo") == ["bar"]
    headers["foo"] = "bar, voing"
    assert get_header_tokens(headers, "foo") == ["bar", "voing"]
    headers.set_all("foo", ["bar, voing", "oink"])
    assert get_header_tokens(headers, "foo") == ["bar", "voing", "oink"]


def test_connection_close():

            

Reported by Bandit.

                  headers["foo"] = "bar, voing"
    assert get_header_tokens(headers, "foo") == ["bar", "voing"]
    headers.set_all("foo", ["bar, voing", "oink"])
    assert get_header_tokens(headers, "foo") == ["bar", "voing", "oink"]


def test_connection_close():
    headers = Headers()
    assert connection_close(b"HTTP/1.0", headers)

            

Reported by Bandit.

                  assert get_header_tokens(headers, "foo") == ["bar", "voing", "oink"]


def test_connection_close():
    headers = Headers()
    assert connection_close(b"HTTP/1.0", headers)
    assert not connection_close(b"HTTP/1.1", headers)
    assert not connection_close(b"HTTP/2.0", headers)


            

Reported by Pylint.

              
def test_connection_close():
    headers = Headers()
    assert connection_close(b"HTTP/1.0", headers)
    assert not connection_close(b"HTTP/1.1", headers)
    assert not connection_close(b"HTTP/2.0", headers)

    headers["connection"] = "keep-alive"
    assert not connection_close(b"HTTP/1.1", headers)

            

Reported by Bandit.

              def test_connection_close():
    headers = Headers()
    assert connection_close(b"HTTP/1.0", headers)
    assert not connection_close(b"HTTP/1.1", headers)
    assert not connection_close(b"HTTP/2.0", headers)

    headers["connection"] = "keep-alive"
    assert not connection_close(b"HTTP/1.1", headers)


            

Reported by Bandit.

              from unittest import mock
from unittest.mock import MagicMock

from mitmproxy.test import tflow
from mitmproxy.test import tutils

from examples.contrib.webscanner_helper.mapping import MappingAddon, MappingAddonConfig



            

Reported by Pylint.

              from unittest.mock import MagicMock

from mitmproxy.test import tflow
from mitmproxy.test import tutils

from examples.contrib.webscanner_helper.mapping import MappingAddon, MappingAddonConfig


class TestConfig:

            

Reported by Pylint.

              from mitmproxy.test import tflow
from mitmproxy.test import tutils

from examples.contrib.webscanner_helper.mapping import MappingAddon, MappingAddonConfig


class TestConfig:

    def test_config(self):

            

Reported by Pylint.

                      else:
            assert False

    def test_dump(selfself, tmpdir):
        tmpfile = tmpdir.join("tmpfile")
        with open(tmpfile, "w") as tfile:
            tfile.write("{}")
        mapping = MappingAddon(tmpfile, persistent=True)
        with mock.patch('examples.complex.webscanner_helper.urldict.URLDict.dump', selfself.mock_dump):

            

Reported by Pylint.

                      with open(tmpfile, "w") as tfile:
            tfile.write(mapping_content)
        mapping = MappingAddon(tmpfile)
        assert "My Text" in str(mapping.mapping_templates._dump())

    def test_load(self, tmpdir):
        tmpfile = tmpdir.join("tmpfile")
        with open(tmpfile, "w") as tfile:
            tfile.write(mapping_content)

            

Reported by Pylint.

                          results = tfile.read()
        assert mapping_content in results

    def mock_dump(self, f: TextIO, value_dumper: Callable):
        assert value_dumper(None) == "None"
        try:
            value_dumper("Test")
        except RuntimeError:
            assert True

            

Reported by Pylint.

              from typing import TextIO, Callable
from unittest import mock
from unittest.mock import MagicMock

from mitmproxy.test import tflow
from mitmproxy.test import tutils

from examples.contrib.webscanner_helper.mapping import MappingAddon, MappingAddonConfig


            

Reported by Pylint.

              from examples.contrib.webscanner_helper.mapping import MappingAddon, MappingAddonConfig


class TestConfig:

    def test_config(self):
        assert MappingAddonConfig.HTML_PARSER == "html.parser"



            

Reported by Pylint.

              from examples.contrib.webscanner_helper.mapping import MappingAddon, MappingAddonConfig


class TestConfig:

    def test_config(self):
        assert MappingAddonConfig.HTML_PARSER == "html.parser"



            

Reported by Pylint.

              
class TestConfig:

    def test_config(self):
        assert MappingAddonConfig.HTML_PARSER == "html.parser"


url = "http://10.10.10.10"
new_content = "My Text"

            

Reported by Pylint.

              
from OpenSSL.crypto import X509
from cryptography.hazmat.primitives.asymmetric import rsa
from kaitaistruct import KaitaiStream

from OpenSSL import SSL, crypto
from mitmproxy import certs
from mitmproxy.contrib.kaitaistruct import tls_client_hello
from mitmproxy.net import check

            

Reported by Pylint.

              
    # SSLKEYLOGFILE
    if log_master_secret:
        context.set_keylog_callback(log_master_secret)

    return context


@lru_cache(256)

            

Reported by Pylint.

              
# redeclared here for strict type checking
class Method(Enum):
    # TODO: just SSL attributes once https://github.com/pyca/pyopenssl/pull/985 has landed.
    TLS_SERVER_METHOD = getattr(SSL, "TLS_SERVER_METHOD", 8)
    TLS_CLIENT_METHOD = getattr(SSL, "TLS_CLIENT_METHOD", 9)


# TODO: remove once https://github.com/pyca/pyopenssl/pull/985 has landed.

            

Reported by Pylint.

                  TLS_CLIENT_METHOD = getattr(SSL, "TLS_CLIENT_METHOD", 9)


# TODO: remove once https://github.com/pyca/pyopenssl/pull/985 has landed.
try:
    SSL._lib.TLS_server_method  # type: ignore
except AttributeError as e:  # pragma: no cover
    raise RuntimeError("Your installation of the cryptography Python package is outdated.") from e


            

Reported by Pylint.

              
# TODO: remove once https://github.com/pyca/pyopenssl/pull/985 has landed.
try:
    SSL._lib.TLS_server_method  # type: ignore
except AttributeError as e:  # pragma: no cover
    raise RuntimeError("Your installation of the cryptography Python package is outdated.") from e

SSL.Context._methods.setdefault(Method.TLS_SERVER_METHOD.value, SSL._lib.TLS_server_method)  # type: ignore
SSL.Context._methods.setdefault(Method.TLS_CLIENT_METHOD.value, SSL._lib.TLS_client_method)  # type: ignore

            

Reported by Pylint.

              except AttributeError as e:  # pragma: no cover
    raise RuntimeError("Your installation of the cryptography Python package is outdated.") from e

SSL.Context._methods.setdefault(Method.TLS_SERVER_METHOD.value, SSL._lib.TLS_server_method)  # type: ignore
SSL.Context._methods.setdefault(Method.TLS_CLIENT_METHOD.value, SSL._lib.TLS_client_method)  # type: ignore


class Version(Enum):
    UNBOUNDED = 0

            

Reported by Pylint.

              except AttributeError as e:  # pragma: no cover
    raise RuntimeError("Your installation of the cryptography Python package is outdated.") from e

SSL.Context._methods.setdefault(Method.TLS_SERVER_METHOD.value, SSL._lib.TLS_server_method)  # type: ignore
SSL.Context._methods.setdefault(Method.TLS_CLIENT_METHOD.value, SSL._lib.TLS_client_method)  # type: ignore


class Version(Enum):
    UNBOUNDED = 0

            

Reported by Pylint.

                  raise RuntimeError("Your installation of the cryptography Python package is outdated.") from e

SSL.Context._methods.setdefault(Method.TLS_SERVER_METHOD.value, SSL._lib.TLS_server_method)  # type: ignore
SSL.Context._methods.setdefault(Method.TLS_CLIENT_METHOD.value, SSL._lib.TLS_client_method)  # type: ignore


class Version(Enum):
    UNBOUNDED = 0
    # TODO: just SSL attributes once https://github.com/pyca/pyopenssl/pull/985 has landed.

            

Reported by Pylint.

                  raise RuntimeError("Your installation of the cryptography Python package is outdated.") from e

SSL.Context._methods.setdefault(Method.TLS_SERVER_METHOD.value, SSL._lib.TLS_server_method)  # type: ignore
SSL.Context._methods.setdefault(Method.TLS_CLIENT_METHOD.value, SSL._lib.TLS_client_method)  # type: ignore


class Version(Enum):
    UNBOUNDED = 0
    # TODO: just SSL attributes once https://github.com/pyca/pyopenssl/pull/985 has landed.

            

Reported by Pylint.

              
class Version(Enum):
    UNBOUNDED = 0
    # TODO: just SSL attributes once https://github.com/pyca/pyopenssl/pull/985 has landed.
    SSL3 = getattr(SSL, "SSL3_VERSION", 768)
    TLS1 = getattr(SSL, "TLS1_VERSION", 768)
    TLS1_1 = getattr(SSL, "TLS1_1_VERSION", 770)
    TLS1_2 = getattr(SSL, "TLS1_2_VERSION", 771)
    TLS1_3 = getattr(SSL, "TLS1_3_VERSION", 772)

            

Reported by Pylint.

              from enum import Enum
from typing import ClassVar, DefaultDict, Dict, List, Optional, Sequence, Tuple, Type, Union

import h2.config
import h2.connection
import h2.errors
import h2.events
import h2.exceptions
import h2.settings

            

Reported by Pylint.

              from typing import ClassVar, DefaultDict, Dict, List, Optional, Sequence, Tuple, Type, Union

import h2.config
import h2.connection
import h2.errors
import h2.events
import h2.exceptions
import h2.settings
import h2.stream

            

Reported by Pylint.

              
import h2.config
import h2.connection
import h2.errors
import h2.events
import h2.exceptions
import h2.settings
import h2.stream
import h2.utilities

            

Reported by Pylint.

              import h2.config
import h2.connection
import h2.errors
import h2.events
import h2.exceptions
import h2.settings
import h2.stream
import h2.utilities


            

Reported by Pylint.

              import h2.connection
import h2.errors
import h2.events
import h2.exceptions
import h2.settings
import h2.stream
import h2.utilities

from mitmproxy import http, version

            

Reported by Pylint.

              import h2.errors
import h2.events
import h2.exceptions
import h2.settings
import h2.stream
import h2.utilities

from mitmproxy import http, version
from mitmproxy.connection import Connection

            

Reported by Pylint.

              import h2.events
import h2.exceptions
import h2.settings
import h2.stream
import h2.utilities

from mitmproxy import http, version
from mitmproxy.connection import Connection
from mitmproxy.net.http import status_codes, url

            

Reported by Pylint.

              import h2.exceptions
import h2.settings
import h2.stream
import h2.utilities

from mitmproxy import http, version
from mitmproxy.connection import Connection
from mitmproxy.net.http import status_codes, url
from mitmproxy.utils import human

            

Reported by Pylint.

              from mitmproxy.connection import Connection
from mitmproxy.net.http import status_codes, url
from mitmproxy.utils import human
from . import RequestData, RequestEndOfMessage, RequestHeaders, RequestProtocolError, ResponseData, \
    ResponseEndOfMessage, ResponseHeaders, RequestTrailers, ResponseTrailers, ResponseProtocolError
from ._base import HttpConnection, HttpEvent, ReceiveHttp, format_error
from ._http_h2 import BufferedH2Connection, H2ConnectionLogger
from ...commands import CloseConnection, Log, SendData
from ...context import Context

            

Reported by Pylint.

              from mitmproxy.utils import human
from . import RequestData, RequestEndOfMessage, RequestHeaders, RequestProtocolError, ResponseData, \
    ResponseEndOfMessage, ResponseHeaders, RequestTrailers, ResponseTrailers, ResponseProtocolError
from ._base import HttpConnection, HttpEvent, ReceiveHttp, format_error
from ._http_h2 import BufferedH2Connection, H2ConnectionLogger
from ...commands import CloseConnection, Log, SendData
from ...context import Context
from ...events import ConnectionClosed, DataReceived, Event, Start
from ...layer import CommandGenerator

            

Reported by Pylint.