# coding: utf-8

"""
    KubeVirt API

    This is KubeVirt API an add-on for Kubernetes.  # noqa: E501

    OpenAPI spec version: 1.0.0
    Contact: kubevirt-dev@googlegroups.com
    Generated by: https://github.com/swagger-api/swagger-codegen.git
"""


import pprint
import re  # noqa: F401

import six

from kubevirt.configuration import Configuration


class V1LogVerbosity(object):
    """NOTE: This class is auto generated by the swagger code generator program.

    Do not edit the class manually.
    """

    """
    Attributes:
      swagger_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    swagger_types = {
        'node_verbosity': 'dict(str, int)',
        'virt_api': 'int',
        'virt_controller': 'int',
        'virt_handler': 'int',
        'virt_launcher': 'int',
        'virt_operator': 'int',
        'virt_synchronization_controller': 'int'
    }

    attribute_map = {
        'node_verbosity': 'nodeVerbosity',
        'virt_api': 'virtAPI',
        'virt_controller': 'virtController',
        'virt_handler': 'virtHandler',
        'virt_launcher': 'virtLauncher',
        'virt_operator': 'virtOperator',
        'virt_synchronization_controller': 'virtSynchronizationController'
    }

    def __init__(self, node_verbosity=None, virt_api=None, virt_controller=None, virt_handler=None, virt_launcher=None, virt_operator=None, virt_synchronization_controller=None, _configuration=None):  # noqa: E501
        """V1LogVerbosity - a model defined in Swagger"""  # noqa: E501
        if _configuration is None:
            _configuration = Configuration()
        self._configuration = _configuration

        self._node_verbosity = None
        self._virt_api = None
        self._virt_controller = None
        self._virt_handler = None
        self._virt_launcher = None
        self._virt_operator = None
        self._virt_synchronization_controller = None
        self.discriminator = None

        if node_verbosity is not None:
            self.node_verbosity = node_verbosity
        if virt_api is not None:
            self.virt_api = virt_api
        if virt_controller is not None:
            self.virt_controller = virt_controller
        if virt_handler is not None:
            self.virt_handler = virt_handler
        if virt_launcher is not None:
            self.virt_launcher = virt_launcher
        if virt_operator is not None:
            self.virt_operator = virt_operator
        if virt_synchronization_controller is not None:
            self.virt_synchronization_controller = virt_synchronization_controller

    @property
    def node_verbosity(self):
        """Gets the node_verbosity of this V1LogVerbosity.  # noqa: E501

        NodeVerbosity represents a map of nodes with a specific verbosity level  # noqa: E501

        :return: The node_verbosity of this V1LogVerbosity.  # noqa: E501
        :rtype: dict(str, int)
        """
        return self._node_verbosity

    @node_verbosity.setter
    def node_verbosity(self, node_verbosity):
        """Sets the node_verbosity of this V1LogVerbosity.

        NodeVerbosity represents a map of nodes with a specific verbosity level  # noqa: E501

        :param node_verbosity: The node_verbosity of this V1LogVerbosity.  # noqa: E501
        :type: dict(str, int)
        """

        self._node_verbosity = node_verbosity

    @property
    def virt_api(self):
        """Gets the virt_api of this V1LogVerbosity.  # noqa: E501


        :return: The virt_api of this V1LogVerbosity.  # noqa: E501
        :rtype: int
        """
        return self._virt_api

    @virt_api.setter
    def virt_api(self, virt_api):
        """Sets the virt_api of this V1LogVerbosity.


        :param virt_api: The virt_api of this V1LogVerbosity.  # noqa: E501
        :type: int
        """

        self._virt_api = virt_api

    @property
    def virt_controller(self):
        """Gets the virt_controller of this V1LogVerbosity.  # noqa: E501


        :return: The virt_controller of this V1LogVerbosity.  # noqa: E501
        :rtype: int
        """
        return self._virt_controller

    @virt_controller.setter
    def virt_controller(self, virt_controller):
        """Sets the virt_controller of this V1LogVerbosity.


        :param virt_controller: The virt_controller of this V1LogVerbosity.  # noqa: E501
        :type: int
        """

        self._virt_controller = virt_controller

    @property
    def virt_handler(self):
        """Gets the virt_handler of this V1LogVerbosity.  # noqa: E501


        :return: The virt_handler of this V1LogVerbosity.  # noqa: E501
        :rtype: int
        """
        return self._virt_handler

    @virt_handler.setter
    def virt_handler(self, virt_handler):
        """Sets the virt_handler of this V1LogVerbosity.


        :param virt_handler: The virt_handler of this V1LogVerbosity.  # noqa: E501
        :type: int
        """

        self._virt_handler = virt_handler

    @property
    def virt_launcher(self):
        """Gets the virt_launcher of this V1LogVerbosity.  # noqa: E501


        :return: The virt_launcher of this V1LogVerbosity.  # noqa: E501
        :rtype: int
        """
        return self._virt_launcher

    @virt_launcher.setter
    def virt_launcher(self, virt_launcher):
        """Sets the virt_launcher of this V1LogVerbosity.


        :param virt_launcher: The virt_launcher of this V1LogVerbosity.  # noqa: E501
        :type: int
        """

        self._virt_launcher = virt_launcher

    @property
    def virt_operator(self):
        """Gets the virt_operator of this V1LogVerbosity.  # noqa: E501


        :return: The virt_operator of this V1LogVerbosity.  # noqa: E501
        :rtype: int
        """
        return self._virt_operator

    @virt_operator.setter
    def virt_operator(self, virt_operator):
        """Sets the virt_operator of this V1LogVerbosity.


        :param virt_operator: The virt_operator of this V1LogVerbosity.  # noqa: E501
        :type: int
        """

        self._virt_operator = virt_operator

    @property
    def virt_synchronization_controller(self):
        """Gets the virt_synchronization_controller of this V1LogVerbosity.  # noqa: E501


        :return: The virt_synchronization_controller of this V1LogVerbosity.  # noqa: E501
        :rtype: int
        """
        return self._virt_synchronization_controller

    @virt_synchronization_controller.setter
    def virt_synchronization_controller(self, virt_synchronization_controller):
        """Sets the virt_synchronization_controller of this V1LogVerbosity.


        :param virt_synchronization_controller: The virt_synchronization_controller of this V1LogVerbosity.  # noqa: E501
        :type: int
        """

        self._virt_synchronization_controller = virt_synchronization_controller

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.swagger_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value
        if issubclass(V1LogVerbosity, dict):
            for key, value in self.items():
                result[key] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, V1LogVerbosity):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, V1LogVerbosity):
            return True

        return self.to_dict() != other.to_dict()
