Code Coverage - ajoaoff/mef_eline - Measure and Improve Code Quality continuously with Scrutinizer

Code

setup.py

< 40 %

40-60 %

> 60 %

"""Setup script.

Run "python3 setup.py --help-commands" to list all available commands and their
descriptions.
"""
import os
import shutil
import sys
from abc import abstractmethod
from pathlib import Path
from string import Template
from subprocess import CalledProcessError, call, check_call

from setuptools import Command, setup
from setuptools.command.develop import develop
from setuptools.command.egg_info import egg_info
from setuptools.command.install import install

if "bdist_wheel" in sys.argv:
    raise RuntimeError("This setup.py does not support wheels")

# Paths setup with virtualenv detection
BASE_ENV = Path(os.environ.get("VIRTUAL_ENV", "/"))

NAPP_NAME = 'mef_eline'
NAPP_VERSION = '2022.1.5'

# Kytos var folder
VAR_PATH = BASE_ENV / "var" / "lib" / "kytos"
# Path for enabled NApps
ENABLED_PATH = VAR_PATH / "napps"
# Path to install NApps
INSTALLED_PATH = VAR_PATH / "napps" / ".installed"
CURRENT_DIR = Path(".").resolve()

# NApps enabled by default
CORE_NAPPS = ["of_core"]


class SimpleCommand(Command):
    """Make Command implementation simpler."""

    user_options = []

    @abstractmethod
    def run(self):
        """Run when command is invoked.

        Use *call* instead of *check_call* to ignore failures.
        """

    def initialize_options(self):
        """Set default values for options."""

    def finalize_options(self):
        """Post-process options."""


# pylint: disable=attribute-defined-outside-init, abstract-method
class TestCommand(Command):
    """Test tags decorators."""

    user_options = [
        ("size=", None, "Specify the size of tests to be executed."),
        ("type=", None, "Specify the type of tests to be executed."),
    ]

    sizes = ("small", "medium", "large", "all")
    types = ("unit", "integration", "e2e")

    def get_args(self):
        """Return args to be used in test command."""
        tmpl = Template("--size ${size} --type ${type}")
        data = {"size": self.size, "type": self.type}
        return tmpl.substitute(data)

    def initialize_options(self):
        """Set default size and type args."""
        self.size = "all"
        self.type = "unit"

    def finalize_options(self):
        """Post-process."""
        try:
            assert self.size in self.sizes, (
                "ERROR: Invalid size:" f":{self.size}"
            )
            assert self.type in self.types, (
                "ERROR: Invalid type:" f":{self.type}"
            )
        except AssertionError as exc:
            print(exc)
            sys.exit(-1)


class Cleaner(SimpleCommand):
    """Custom clean command to tidy up the project root."""

    description = "clean build, dist, pyc and egg from package and docs"

    def run(self):
        """Clean build, dist, pyc and egg from package and docs."""
        call("rm -vrf ./build ./dist ./*.egg-info", shell=True)
        call("find . -name __pycache__ -type d | xargs rm -rf", shell=True)
        call("make -C docs/ clean", shell=True)


class Test(TestCommand):
    """Run all tests."""

    description = "run tests and display results"

    def get_args(self):
        """Return args to be used in test command."""
        markers = self.size
        if markers == "small":
            markers = "not medium and not large"
        size_args = ""
        if self.size != "all":
            size_args = Template("-m '${markers}'")
        add_opts = Template('--addopts="tests/${type} ${args}"')
        data = {"type": self.type, "args": size_args}
        return add_opts.substitute(data)

    def run(self):
        """Run tests."""
        cmd = f"python setup.py pytest {0}".format(self.get_args())
        try:
            check_call(cmd, shell=True)
        except CalledProcessError as exc:
            print(exc)
            print("Unit tests failed. Fix the errors above and try again.")
            sys.exit(-1)


class TestCoverage(Test):
    """Display test coverage."""

    description = "run tests and display code coverage"

    def run(self):
        """Run tests quietly and display coverage report."""
        # cmd = 'coverage3 run setup.py pytest %s' % self.get_args()
        tmpl = Template(
            "coverage3 run setup.py pytest ${arg1} && coverage3 report"
        )
        cmd = tmpl.substitute(arg1=self.get_args())
        try:
            check_call(cmd, shell=True)
        except CalledProcessError as exc:
            print(exc)
            print(
                "Coverage tests failed. Fix the errors abov e and try again."
            )
            sys.exit(-1)


class Linter(SimpleCommand):
    """Code linters."""

    description = "lint Python source code"

    def run(self):
        """Run Yala."""
        print("Yala is running. It may take several seconds...")
        try:
            cmd = "yala *.py tests"
            check_call(cmd, shell=True)
            print("No linter error found.")
        except CalledProcessError:
            print("Linter check failed. Fix the error(s) above and try again.")
            sys.exit(-1)


class CITest(TestCommand):
    """Run all CI tests."""

    description = "run all CI tests: unit and doc tests, linter"

    def run(self):
        """Run unit tests with coverage, doc tests and linter."""
        coverage_cmd = f"python3.6 setup.py coverage {0}".format(
            self.get_args()
        )
        lint_cmd = "python3.6 setup.py lint"
        cmd = f"{0} && {1}".format(coverage_cmd, lint_cmd)
        check_call(cmd, shell=True)


class KytosInstall:
    """Common code for all install types."""

    @staticmethod
    def enable_core_napps():
        """Enable a NAPP by creating a symlink."""
        (ENABLED_PATH / "kytos").mkdir(parents=True, exist_ok=True)
        for napp in CORE_NAPPS:
            napp_path = Path("kytos", napp)
            src = ENABLED_PATH / napp_path
            dst = INSTALLED_PATH / napp_path
            symlink_if_different(src, dst)

    def __str__(self):
        return self.__class__.__name__


class InstallMode(install):
    """Create files in var/lib/kytos."""

    description = 'To install NApps, use kytos-utils. Devs, see "develop".'

    def run(self):
        """Direct users to use kytos-utils to install NApps."""
        print(self.description)


class EggInfo(egg_info):
    """Prepare files to be packed."""

    def run(self):
        """Build css."""
        self._install_deps_wheels()
        super().run()

    @staticmethod
    def _install_deps_wheels():
        """Python wheels are much faster (no compiling)."""
        print("Installing dependencies...")
        check_call(
            [
                sys.executable,
                "-m",
                "pip",
                "install",
                "-r",
                "requirements/run.txt",
            ]
        )


class DevelopMode(develop):
    """Recommended setup for kytos-napps developers.

    Instead of copying the files to the expected directories, a symlink is
    created on the system aiming the current source code.
    """

    description = "Install NApps in development mode"

    def run(self):
        """Install the package in a developer mode."""
        super().run()
        if self.uninstall:
            shutil.rmtree(str(ENABLED_PATH), ignore_errors=True)
        else:
            self._create_folder_symlinks()
            # self._create_file_symlinks()
            KytosInstall.enable_core_napps()

    @staticmethod
    def _create_folder_symlinks():
        """Symlink to all Kytos NApps folders.

        ./napps/kytos/napp_name will generate a link in
        var/lib/kytos/napps/.installed/kytos/napp_name.
        """
        links = INSTALLED_PATH / "kytos"
        links.mkdir(parents=True, exist_ok=True)
        code = CURRENT_DIR
        src = links / NAPP_NAME
        symlink_if_different(src, code)

        (ENABLED_PATH / "kytos").mkdir(parents=True, exist_ok=True)
        dst = ENABLED_PATH / Path("kytos", NAPP_NAME)
        symlink_if_different(dst, src)

    @staticmethod
    def _create_file_symlinks():
        """Symlink to required files."""
        src = ENABLED_PATH / "__init__.py"
        dst = CURRENT_DIR / "napps" / "__init__.py"
        symlink_if_different(src, dst)


def symlink_if_different(path, target):
    """Force symlink creation if it points anywhere else."""
    # print(f"symlinking {path} to target: {target}...", end=" ")
    if not path.exists():
        # print(f"path doesn't exist. linking...")
        path.symlink_to(target)
    elif not path.samefile(target):
        # print(f"path exists, but is different. removing and linking...")
        # Exists but points to a different file, so let's replace it
        path.unlink()
        path.symlink_to(target)


def read_requirements(path="requirements/run.txt"):
    """Read requirements file and return a list."""
    with open(path, "r", encoding="utf8") as file:
        return [
            line.strip()
            for line in file.readlines()
            if not line.startswith("#")
        ]


setup(
    name=f"kytos_{NAPP_NAME}",
    version=NAPP_VERSION,
    description="Core NApps developed by Kytos Team",
    url="http://github.com/kytos/{NAPP_NAME}",
    author="Kytos Team",
    author_email="[email protected]",
    license="MIT",
    install_requires=read_requirements() + ["setuptools >= 36.0.1"],
    setup_requires=["pytest-runner"],
    tests_require=["pytest==7.0.0"],
    extras_require={
        "dev": [
            "coverage",
            "pip-tools",
            "yala",
            "tox",
        ],
    },
    cmdclass={
        "clean": Cleaner,
        "ci": CITest,
        "coverage": TestCoverage,
        "develop": DevelopMode,
        "install": InstallMode,
        "lint": Linter,
        "egg_info": EggInfo,
        "test": Test,
    },
    zip_safe=False,
    classifiers=[
        "License :: OSI Approved :: MIT License",
        "Operating System :: POSIX :: Linux",
        "Programming Language :: Python :: 3.6",
        "Topic :: System :: Networking",
    ],
)


1			"""Setup script.
2
3			Run "python3 setup.py --help-commands" to list all available commands and their
4			descriptions.
5			"""
6			import os
7			import shutil
8			import sys
9			from abc import abstractmethod
10			from pathlib import Path
11			from string import Template
12			from subprocess import CalledProcessError, call, check_call
13
14			from setuptools import Command, setup
15			from setuptools.command.develop import develop
16			from setuptools.command.egg_info import egg_info
17			from setuptools.command.install import install
18
19			if "bdist_wheel" in sys.argv:
20			raise RuntimeError("This setup.py does not support wheels")
21
22			# Paths setup with virtualenv detection
23			BASE_ENV = Path(os.environ.get("VIRTUAL_ENV", "/"))
24
25			NAPP_NAME = 'mef_eline'
26			NAPP_VERSION = '2022.1.5'
27
28			# Kytos var folder
29			VAR_PATH = BASE_ENV / "var" / "lib" / "kytos"
30			# Path for enabled NApps
31			ENABLED_PATH = VAR_PATH / "napps"
32			# Path to install NApps
33			INSTALLED_PATH = VAR_PATH / "napps" / ".installed"
34			CURRENT_DIR = Path(".").resolve()
35
36			# NApps enabled by default
37			CORE_NAPPS = ["of_core"]
38
39
40			class SimpleCommand(Command):
41			"""Make Command implementation simpler."""
42
43			user_options = []
44
45			@abstractmethod
46			def run(self):
47			"""Run when command is invoked.
48
49			Use call instead of check_call to ignore failures.
50			"""
51
52			def initialize_options(self):
53			"""Set default values for options."""
54
55			def finalize_options(self):
56			"""Post-process options."""
57
58
59			# pylint: disable=attribute-defined-outside-init, abstract-method
60			class TestCommand(Command):
61			"""Test tags decorators."""
62
63			user_options = [
64			("size=", None, "Specify the size of tests to be executed."),
65			("type=", None, "Specify the type of tests to be executed."),
66			]
67
68			sizes = ("small", "medium", "large", "all")
69			types = ("unit", "integration", "e2e")
70
71			def get_args(self):
72			"""Return args to be used in test command."""
73			tmpl = Template("--size ${size} --type ${type}")
74			data = {"size": self.size, "type": self.type}
75			return tmpl.substitute(data)
76
77			def initialize_options(self):
78			"""Set default size and type args."""
79			self.size = "all"
80			self.type = "unit"
81
82			def finalize_options(self):
83			"""Post-process."""
84			try:
85			assert self.size in self.sizes, (
86			"ERROR: Invalid size:" f":{self.size}"
87			)
88			assert self.type in self.types, (
89			"ERROR: Invalid type:" f":{self.type}"
90			)
91			except AssertionError as exc:
92			print(exc)
93			sys.exit(-1)
94
95
96			class Cleaner(SimpleCommand):
97			"""Custom clean command to tidy up the project root."""
98
99			description = "clean build, dist, pyc and egg from package and docs"
100
101			def run(self):
102			"""Clean build, dist, pyc and egg from package and docs."""
103			call("rm -vrf ./build ./dist ./*.egg-info", shell=True)
104			call("find . -name __pycache__ -type d \| xargs rm -rf", shell=True)
105			call("make -C docs/ clean", shell=True)
106
107
108			class Test(TestCommand):
109			"""Run all tests."""
110
111			description = "run tests and display results"
112
113			def get_args(self):
114			"""Return args to be used in test command."""
115			markers = self.size
116			if markers == "small":
117			markers = "not medium and not large"
118			size_args = ""
119			if self.size != "all":
120			size_args = Template("-m '${markers}'")
121			add_opts = Template('--addopts="tests/${type} ${args}"')
122			data = {"type": self.type, "args": size_args}
123			return add_opts.substitute(data)
124
125			def run(self):
126			"""Run tests."""
127			cmd = f"python setup.py pytest {0}".format(self.get_args())
128			try:
129			check_call(cmd, shell=True)
130			except CalledProcessError as exc:
131			print(exc)
132			print("Unit tests failed. Fix the errors above and try again.")
133			sys.exit(-1)
134
135
136			class TestCoverage(Test):
137			"""Display test coverage."""
138
139			description = "run tests and display code coverage"
140
141			def run(self):
142			"""Run tests quietly and display coverage report."""
143			# cmd = 'coverage3 run setup.py pytest %s' % self.get_args()
144			tmpl = Template(
145			"coverage3 run setup.py pytest ${arg1} && coverage3 report"
146			)
147			cmd = tmpl.substitute(arg1=self.get_args())
148			try:
149			check_call(cmd, shell=True)
150			except CalledProcessError as exc:
151			print(exc)
152			print(
153			"Coverage tests failed. Fix the errors abov e and try again."
154			)
155			sys.exit(-1)
156
157
158			class Linter(SimpleCommand):
159			"""Code linters."""
160
161			description = "lint Python source code"
162
163			def run(self):
164			"""Run Yala."""
165			print("Yala is running. It may take several seconds...")
166			try:
167			cmd = "yala *.py tests"
168			check_call(cmd, shell=True)
169			print("No linter error found.")
170			except CalledProcessError:
171			print("Linter check failed. Fix the error(s) above and try again.")
172			sys.exit(-1)
173
174
175			class CITest(TestCommand):
176			"""Run all CI tests."""
177
178			description = "run all CI tests: unit and doc tests, linter"
179
180			def run(self):
181			"""Run unit tests with coverage, doc tests and linter."""
182			coverage_cmd = f"python3.6 setup.py coverage {0}".format(
183			self.get_args()
184			)
185			lint_cmd = "python3.6 setup.py lint"
186			cmd = f"{0} && {1}".format(coverage_cmd, lint_cmd)
187			check_call(cmd, shell=True)
188
189
190			class KytosInstall:
191			"""Common code for all install types."""
192
193			@staticmethod
194			def enable_core_napps():
195			"""Enable a NAPP by creating a symlink."""
196			(ENABLED_PATH / "kytos").mkdir(parents=True, exist_ok=True)
197			for napp in CORE_NAPPS:
198			napp_path = Path("kytos", napp)
199			src = ENABLED_PATH / napp_path
200			dst = INSTALLED_PATH / napp_path
201			symlink_if_different(src, dst)
202
203			def __str__(self):
204			return self.__class__.__name__
205
206
207			class InstallMode(install):
208			"""Create files in var/lib/kytos."""
209
210			description = 'To install NApps, use kytos-utils. Devs, see "develop".'
211
212			def run(self):
213			"""Direct users to use kytos-utils to install NApps."""
214			print(self.description)
215
216
217			class EggInfo(egg_info):
218			"""Prepare files to be packed."""
219
220			def run(self):
221			"""Build css."""
222			self._install_deps_wheels()
223			super().run()
224
225			@staticmethod
226			def _install_deps_wheels():
227			"""Python wheels are much faster (no compiling)."""
228			print("Installing dependencies...")
229			check_call(
230			[
231			sys.executable,
232			"-m",
233			"pip",
234			"install",
235			"-r",
236			"requirements/run.txt",
237			]
238			)
239
240
241			class DevelopMode(develop):
242			"""Recommended setup for kytos-napps developers.
243
244			Instead of copying the files to the expected directories, a symlink is
245			created on the system aiming the current source code.
246			"""
247
248			description = "Install NApps in development mode"
249
250			def run(self):
251			"""Install the package in a developer mode."""
252			super().run()
253			if self.uninstall:
254			shutil.rmtree(str(ENABLED_PATH), ignore_errors=True)
255			else:
256			self._create_folder_symlinks()
257			# self._create_file_symlinks()
258			KytosInstall.enable_core_napps()
259
260			@staticmethod
261			def _create_folder_symlinks():
262			"""Symlink to all Kytos NApps folders.
263
264			./napps/kytos/napp_name will generate a link in
265			var/lib/kytos/napps/.installed/kytos/napp_name.
266			"""
267			links = INSTALLED_PATH / "kytos"
268			links.mkdir(parents=True, exist_ok=True)
269			code = CURRENT_DIR
270			src = links / NAPP_NAME
271			symlink_if_different(src, code)
272
273			(ENABLED_PATH / "kytos").mkdir(parents=True, exist_ok=True)
274			dst = ENABLED_PATH / Path("kytos", NAPP_NAME)
275			symlink_if_different(dst, src)
276
277			@staticmethod
278			def _create_file_symlinks():
279			"""Symlink to required files."""
280			src = ENABLED_PATH / "__init__.py"
281			dst = CURRENT_DIR / "napps" / "__init__.py"
282			symlink_if_different(src, dst)
283
284
285			def symlink_if_different(path, target):
286			"""Force symlink creation if it points anywhere else."""
287			# print(f"symlinking {path} to target: {target}...", end=" ")
288			if not path.exists():
289			# print(f"path doesn't exist. linking...")
290			path.symlink_to(target)
291			elif not path.samefile(target):
292			# print(f"path exists, but is different. removing and linking...")
293			# Exists but points to a different file, so let's replace it
294			path.unlink()
295			path.symlink_to(target)
296
297
298			def read_requirements(path="requirements/run.txt"):
299			"""Read requirements file and return a list."""
300			with open(path, "r", encoding="utf8") as file:
301			return [
302			line.strip()
303			for line in file.readlines()
304			if not line.startswith("#")
305			]
306
307
308			setup(
309			name=f"kytos_{NAPP_NAME}",
310			version=NAPP_VERSION,
311			description="Core NApps developed by Kytos Team",
312			url="http://github.com/kytos/{NAPP_NAME}",
313			author="Kytos Team",
314			author_email="[email protected]",
315			license="MIT",
316			install_requires=read_requirements() + ["setuptools >= 36.0.1"],
317			setup_requires=["pytest-runner"],
318			tests_require=["pytest==7.0.0"],
319			extras_require={
320			"dev": [
321			"coverage",
322			"pip-tools",
323			"yala",
324			"tox",
325			],
326			},
327			cmdclass={
328			"clean": Cleaner,
329			"ci": CITest,
330			"coverage": TestCoverage,
331			"develop": DevelopMode,
332			"install": InstallMode,
333			"lint": Linter,
334			"egg_info": EggInfo,
335			"test": Test,
336			},
337			zip_safe=False,
338			classifiers=[
339			"License :: OSI Approved :: MIT License",
340			"Operating System :: POSIX :: Linux",
341			"Programming Language :: Python :: 3.6",
342			"Topic :: System :: Networking",
343			],
344			)
345

ajoaoff / mef_eline

Code