def __init__(self):
self.os_version = None
self.os_version_name = None
self.is_linux = platform.system() == "Linux"
self.linux_distro = None
self.is_windows = platform.system() == "Windows"
self.is_macos = platform.system() == "Darwin"
self.is_freebsd = platform.system() == "FreeBSD"
self.is_solaris = platform.system() == "SunOS"
if self.is_linux:
import distro
self.linux_distro = distro.id()
self.os_version = Version(distro.version())
version_name = distro.codename()
self.os_version_name = version_name if version_name != "n/a" else ""
if not self.os_version_name and self.linux_distro == "debian":
self.os_version_name = self.get_debian_version_name(self.os_version)
elif self.is_windows:
self.os_version = self.get_win_os_version()
self.os_version_name = self.get_win_version_name(self.os_version)
elif self.is_macos:
self.os_version = Version(platform.mac_ver()[0])
self.os_version_name = self.get_osx_version_name(self.os_version)
elif self.is_freebsd:
self.os_version = self.get_freebsd_version()
self.os_version_name = "FreeBSD %s" % self.os_version
elif self.is_solaris:
self.os_version = Version(platform.release())
self.os_version_name = self.get_solaris_version_name(self.os_version)
def __init__(self) -> None:
"""
Creates a new HostDistribution instance.
"""
try:
import distro
self._id = distro.id()
self._name = distro.name(pretty=False)
self._fullname = distro.name(pretty=True)
try:
self._major = int(distro.major_version())
except ValueError:
self._major = -1
try:
self._minor = int(distro.minor_version())
except ValueError:
self._minor = -1
try:
self._build = int(distro.build_number())
except ValueError:
self._build = -1
self._versionstring = distro.version(pretty=False)
self._codename = distro.codename()
self._like = distro.like()
except ImportError:
from suisei.murasame.exceptions import MissingRequirementError
raise MissingRequirementError(
'HostDistribution requires the distro package.',
requirement='distro')
def check_distribution():
'''
Check if the distribution is supported by the installer.
:return: The codename of the distribution
'''
bionic_code_names = ['bionic', 'tara', 'tessa', 'tina', 'disco']
debian_code_names = ['buster', 'stretch', 'kali-rolling']
focal_code_names = ['focal', 'ulyana', 'ulyssa', 'uma']
codename = distro.codename().lower()
if codename in bionic_code_names:
logging.debug('Ubuntu 18.04 detected')
return 'bionic'
if codename in focal_code_names:
logging.debug('Ubuntu 20.04 detected')
return 'focal'
if codename in debian_code_names:
logging.debug('Debian/Kali detected')
return 'debian'
if distro.id() == 'fedora':
logging.debug('Fedora detected')
return 'fedora'
logging.critical(
'Your Distribution ({} {}) is not supported. FACT Installer requires Ubuntu 18.04, 20.04 or compatible!'
.format(distro.id(), distro.version()))
sys.exit(1)
def test_analyze_playability_invalid_wma():
# Liquisoap does not fail with wma files on buster, bullseye, focal, jammy
if distro.codename() in ("buster", "bullseye", "focal", "jammy"):
return
with pytest.raises(UnplayableFileError):
test_analyze_playability(FILE_INVALID_DRM)
def _get_distro_info() -> Tuple[str, str, str, str]:
if psutil.WINDOWS:
return "windows", platform.system(), platform.release(), ""
elif psutil.OSX:
import plistlib
with open("/System/Library/CoreServices/SystemVersion.plist",
"rb") as f:
sw_vers = plistlib.load(f)
return "mac", sw_vers["ProductName"], sw_vers["ProductVersion"], ""
elif _is_android():
import subprocess
android_version = subprocess.run(
["getprop", "ro.build.version.release"],
check=True,
stdout=subprocess.PIPE,
).stdout
return "android", "Android", android_version.decode().strip(), ""
elif psutil.LINUX:
import distro
return distro.id(), distro.name(), distro.version(), distro.codename()
raise NotImplementedError("unsupported OS")
def __init__(self):
self.os_version = None
self.os_version_name = None
self.is_linux = platform.system() == "Linux"
self.linux_distro = None
self.is_windows = platform.system() == "Windows"
self.is_macos = platform.system() == "Darwin"
self.is_freebsd = platform.system() == "FreeBSD"
self.is_solaris = platform.system() == "SunOS"
if self.is_linux:
import distro
self.linux_distro = distro.id()
self.os_version = Version(distro.version())
version_name = distro.codename()
self.os_version_name = version_name if version_name != "n/a" else ""
if not self.os_version_name and self.linux_distro == "debian":
self.os_version_name = self.get_debian_version_name(
self.os_version)
elif self.is_windows:
self.os_version = self.get_win_os_version()
self.os_version_name = self.get_win_version_name(self.os_version)
elif self.is_macos:
self.os_version = Version(platform.mac_ver()[0])
self.os_version_name = self.get_osx_version_name(self.os_version)
elif self.is_freebsd:
self.os_version = self.get_freebsd_version()
self.os_version_name = "FreeBSD %s" % self.os_version
elif self.is_solaris:
self.os_version = Version(platform.release())
self.os_version_name = self.get_solaris_version_name(
self.os_version)
def _get_linux_distro_info(self):
import distro
self.linux_distro = distro.id()
self.os_version = Version(distro.version())
version_name = distro.codename()
self.os_version_name = version_name if version_name != "n/a" else ""
if not self.os_version_name and self.linux_distro == "debian":
self.os_version_name = self.get_debian_version_name(self.os_version)
def get_distribution_version():
"""
Function to acquire current Distribution Version
This function will return the current distribution version
if the user is running on a Linux machine.
"""
return distro.codename()
def test_compute_replaygain(filepath, replaygain):
tolerance = 0.8
# On bionic, replaygain is a bit higher for loud mp3 files.
# This huge tolerance makes the test pass, with values devianting from ~-17 to ~-13
if distro.codename() == "bionic" and str(filepath).endswith("+12.mp3"):
tolerance = 5
assert compute_replaygain(filepath) == pytest.approx(replaygain,
abs=tolerance)
def test_analyze_replaygain(filepath, replaygain):
tolerance = 0.8
# On bionic, replaygain is a bit higher for loud mp3 files.
# This huge tolerance makes the test pass, with values devianting from ~-17 to ~-13
if distro.codename() == "bionic" and str(filepath).endswith("+12.mp3"):
tolerance = 5
metadata = analyze_replaygain(filepath, dict())
assert metadata["replay_gain"] == pytest.approx(replaygain, abs=tolerance)
def get_os_distribution():
try:
return platform.dist()
except Exception:
import distro
return [
distro.name(),
distro.major_version() + '.' + distro.minor_version(),
distro.codename()
]
def __init__(self, lsb_name, get_version_fn=None):
self.lsb_name = lsb_name
if distro.__name__ == "distro":
self.lsb_info = (distro.id(), distro.version(), distro.codename())
elif hasattr(distro, "linux_distribution"):
self.lsb_info = distro.linux_distribution(full_distribution_name=0)
elif hasattr(distro, "dist"):
self.lsb_info = distro.dist()
else:
self.lsb_info = None
def check_distribution():
codename = distro.codename().lower()
if codename in XENIAL_CODE_NAMES:
logging.debug('Ubuntu 16.04 detected')
return 'xenial'
if codename in BIONIC_CODE_NAMES:
logging.debug('Ubuntu 18.04 detected')
return 'bionic'
else:
sys.exit('Your Distribution ({} {}) is not supported. FACT Installer requires Ubuntu 16.04, Ubuntu 18.04 or compatible!'.format(distro.id(), distro.version()))
def __init__(self, batch=False):
self.batch = batch
# self.asroot = ifroot()
self._services = set()
self._system_packages = set()
if ifroot():
click.echo("Running as root.")
click.echo("This is getlino version {} running on {} ({} {}).".format(
SETUP_INFO['version'], distro.name(pretty=True), distro.id(),
distro.codename()))
def check_for_supported_os(config, provider):
"""
Checks if VNet is running on a supported OS for a provider
:param dict config: The config generated by get_config()
:param str provider: The provider to check OS support for
:return: bool: True if the current OS is supported, False otherwise
"""
logger.debug(
"Checking if your os is supported for provider {}".format(provider))
return codename().lower(
) in config["providers"][provider]["supported_operating_systems"]
def _collect_os_default(self):
os_info = dict()
os_info["system"] = platform.system()
os_info["release"] = platform.release()
os_info["like"] = distro.like()
os_info["build_number"] = distro.build_number()
os_info["version"] = distro.version()
os_info["name"] = distro.name()
os_info["codename"] = distro.codename()
self._logger.debug(os_info)
return os_info
def get_codename_to_test():
try:
import distro
if distro.id() == 'ubuntu-core':
codename = 'focal'
if distro.version() == '18':
codename = 'bionic'
elif distro.version() == '16':
codename = 'xenial'
return codename
return distro.codename().split()[0].lower()
except (ImportError, CalledProcessError):
import lsb_release
lsb_release.get_distro_information()["CODENAME"]
def check_distribution():
try:
import distro
except ImportError:
errors = subprocess.run('sudo -EH pip3 install distro', shell=True).stderr
if errors:
sys.exit('Could not determine the system´s Linux distribution')
else:
import distro
codename = distro.codename().lower()
supported_ubuntu_xenial_code_names = ['xenial xerus', 'yakkety yak', 'sarah', 'serena', 'sonya', 'sylvia']
if codename in supported_ubuntu_xenial_code_names:
logging.debug('Ubuntu 16.04 detected')
return 'xenial'
else:
sys.exit('Your Distribution ({} {}) is not supported. FACT Installer requires Ubuntu 16.04 or compatible!'.format(distro.id(), distro.version()))
def check_distribution():
codename = distro.codename().lower()
if codename in BIONIC_CODE_NAMES:
logging.debug('Ubuntu 18.04 detected')
return 'bionic'
if codename in FOCAL_CODE_NAMES:
logging.debug('Ubuntu 20.04 detected')
return 'focal'
if codename in DEBIAN_CODE_NAMES:
logging.debug('Debian/Kali detected')
return 'debian'
if distro.id() == 'fedora':
logging.debug('Fedora detected')
return 'fedora'
sys.exit(
'Your Distribution ({} {}) is not supported. FACT Installer requires Ubuntu 18.04, 20.04 or compatible!'
.format(distro.id(), distro.version()))
def check_distribution():
codename = distro.codename().lower()
if codename in XENIAL_CODE_NAMES:
logging.debug('Ubuntu 16.04 detected')
return 'xenial'
if codename in BIONIC_CODE_NAMES:
logging.debug('Ubuntu 18.04 detected')
return 'bionic'
if codename in FOCAL_CODE_NAMES:
logging.debug('Ubuntu 20.04 detected')
return 'focal'
if codename in BUSTER_CODE_NAMES:
logging.debug('Debian 10/Kali detected')
return 'buster'
if codename in BULLSEYE_CODE_NAMES:
logging.debug('Debian 11 detected')
return 'bullseye'
sys.exit('Your Distribution ({} {}) is not supported. FACT Extractor Installer requires Ubuntu 16.04, 18.04, 20.04, or compatible!'.format(distro.id(), distro.version()))
def main():
args = Options()
ColorScheme(args.color)
sections = args.section
if (len(sections) == 0):
sections = [
'header', 'hw', 'load', 'net', 'netsrv', 'security', 'agents'
]
print(
TITLE +
"======================================================================"
+ DEFAULT)
print('{:^70}'.format(version))
print(
TITLE +
"======================================================================"
+ DEFAULT)
for i in range(len(sections)):
# HEADER
if (sections[i] == 'header'):
hostname = gethostname()
row('NAME', hostname)
now = time.strftime("%Y-%m-%d %H:%M (%Z)")
row('DATE', now)
loadavg = os.getloadavg()
uptime = countuptime() + " " + str(os.getloadavg())
row('UPTIME', uptime)
if using_distro:
platf = distro.name() + " " + distro.version(
) + " " + distro.codename()
else:
platf = ' '.join(platform.linux_distribution())
row('OS', platf)
kernelv = platform.platform()
row('KERNEL', kernelv)
# HARDWARE
if (sections[i] == 'hw'):
title('HARDWARE')
dmidecode()
checkvz()
cpuinfo()
meminfo()
disk()
netcards()
def test_compute_silences(filepath, length, cuein, cueout):
result = compute_silences(filepath)
if cuein != 0.0:
assert len(result) > 0
first = result.pop(0)
assert first[0] == pytest.approx(0.0, abs=0.1)
assert first[1] == pytest.approx(cuein, abs=1)
if cueout != length:
# ffmpeg v3 (bionic) does not warn about silence end when the track ends.
# Check for infinity on last silence ending
if distro.codename() == "bionic":
length = inf
assert len(result) > 0
last = result.pop()
assert last[0] == pytest.approx(cueout, abs=1)
assert last[1] == pytest.approx(length, abs=0.1)
def _get_distro_info():
if psutil.WINDOWS:
return "windows", platform.system(), platform.release(), ""
elif psutil.OSX:
from plistlib import readPlist
sw_vers = readPlist("/System/Library/CoreServices/SystemVersion.plist")
return "mac", sw_vers["ProductName"], sw_vers["ProductVersion"], ""
elif _is_android():
from subprocess import check_output
android_version = check_output(["getprop", "ro.build.version.release"])
return "android", "Android", android_version.decode().strip(), ""
elif psutil.LINUX:
import distro
return distro.id(), distro.name(), distro.version(), distro.codename()
raise NotImplementedError("unsupported OS")
def detect(cls):
system = platform.system().lower()
if system == 'windows':
dist = 'windows'
version, *_ = platform.win32_ver()
codename = None
elif system == 'darwin':
dist = 'macos'
version, *_ = platform.mac_ver()
codename = None
else:
dist = distro.id()
version = distro.version()
codename = distro.codename()
return cls(arch=platform.machine(),
system=system,
distro=dist,
version=version,
codename=codename)
def check_distribution():
try:
import distro
except ImportError:
errors = subprocess.run('sudo -EH pip3 install distro',
shell=True).stderr
if errors:
sys.exit('Could not determine the system´s Linux distribution')
else:
import distro
codename = distro.codename().lower()
if codename in XENIAL_CODE_NAMES:
logging.debug('Ubuntu 16.04 detected')
return 'xenial'
if codename in BIONIC_CODE_NAMES:
logging.debug('Ubuntu 18.04 detected')
return 'bionic'
else:
sys.exit(
'Your Distribution ({} {}) is not supported. FACT Installer requires Ubuntu 16.04, Ubuntu 18.04 or compatible!'
.format(distro.id(), distro.version()))
def check_available_fix(self):
if self.distro_info != "local":
distro_name, distro_codename = self.distro_info.split("-")
else:
distro_name = distro.id()
distro_codename = distro.codename()
if distro_name in DEBIAN_DISTROS:
debian_tracker = DebianCVETracker(distro_name, distro_codename,
self.is_backport)
debian_tracker.cve_info(self.all_cve_data)
elif distro_name in REDHAT_DISTROS:
redhat_tracker = RedhatCVETracker(distro_name, distro_codename)
redhat_tracker.cve_info(self.all_cve_data)
elif self.is_backport:
LOGGER.info(
f"CVE Binary Tool doesn't support Backported Fix Utility for {distro_name.capitalize()} at the moment."
)
else:
LOGGER.info(
f"CVE Binary Tool doesn't support Available Fix Utility for {distro_name.capitalize()} at the moment."
)
import distro
import platform
# Параметры системы
OS_RELEASE = distro.codename().split(' ')[0].lower()
PLATFORM_ARCH = platform.machine()
OS_DISTRIBUTION = distro.id().lower()
OS_VERSION = distro.major_version()
# Адрес загрузки исходного кода nginx
NGINX_URL = "http://nginx.org/download"
NGINX_SRPM_URL_MAINLINE = "http://nginx.org/packages/mainline/centos/{}/SRPMS".format(
OS_VERSION)
NGINX_SRPM_URL_STABLE = "http://nginx.org/packages/centos/{}/SRPMS".format(
OS_VERSION)
# Архив со скриптами для создания пакета
DEB_PACKAGE_SCRIPTS_URL_MAINLINE = "http://nginx.org/packages/mainline/{}/pool/nginx/n/nginx".format(
OS_DISTRIBUTION)
DEB_PACKAGE_SCRIPTS_URL_STABLE = "http://nginx.org/packages/{}/pool/nginx/n/nginx".format(
OS_DISTRIBUTION)
# Путь до директории сборки пакета
SRC_PATH = "/usr/src/nginx"
# Error build code
DPKG_FAIL_EXIT_CODE = 29
# Параметры компиляции nginx
DEFAULT_CONFIGURE_PARAMS = [
"--prefix=/etc/nginx",
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import distro
print 'os_release_info: {0}'.format(distro.os_release_info())
print 'lsb_release_info: {0}'.format(distro.lsb_release_info())
print 'distro_release_info: {0}'.format(distro.distro_release_info())
print 'id: {0}'.format(distro.id())
print 'name: {0}'.format(distro.name())
print 'name_pretty: {0}'.format(distro.name(True))
print 'version: {0}'.format(distro.version())
print 'version_pretty: {0}'.format(distro.version(True))
print 'like: {0}'.format(distro.like())
print 'codename: {0}'.format(distro.codename())
print 'linux_distribution_full: {0}'.format(distro.linux_distribution())
print 'linux_distribution: {0}'.format(distro.linux_distribution(False))
print 'major_version: {0}'.format(distro.major_version())
print 'minor_version: {0}'.format(distro.minor_version())
print 'build_number: {0}'.format(distro.build_number())
def platform_profiles(self):
if platform.system() == 'Darwin':
atoms = set(['darwin'])
# detect available macos package managers
if os.system('which brew >/dev/null') == 0:
atoms.add('brew')
self.platform = Brew()
return ["platform:%s" % (atom,) for atom in sorted(atoms)]
distro_id = distro.id()
if not distro_id:
log = logging.getLogger(__name__)
log.error('Unable to determine distro ID. '
'Does /etc/os-release exist or '
'is lsb_release installed?')
raise Exception('Distro name not found')
# NOTE(toabctl): distro can be more than one string (i.e. "SUSE LINUX")
codename = distro.codename().lower()
release = distro.version().lower()
# NOTE(toabctl): space is a delimiter for bindep, so remove the spaces
distro_id = "".join(distro_id.split()).lower()
atoms = set([distro_id])
atoms.update(self.codenamebits(distro_id, codename))
atoms.update(self.releasebits(distro_id, release))
if distro_id in ["debian", "ubuntu"]:
atoms.add("dpkg")
self.platform = Dpkg()
# RPM distros seem to be especially complicated
elif distro_id in ["amzn", "amazonami",
"centos", "rhel",
"redhatenterpriseserver",
"redhatenterpriseworkstation",
"fedora",
"opensuseproject", "opensuse", "opensuse-leap",
"opensuse-tumbleweed", "sles", "suselinux"]:
# Distro aliases
if distro_id in ["redhatenterpriseserver",
"redhatenterpriseworkstation"]:
# just short alias
atoms.add("rhel")
atoms.update(self.codenamebits("rhel", codename))
atoms.update(self.releasebits("rhel", release))
elif distro_id == 'rhel' and 'server' in distro.name().lower():
atoms.add("redhatenterpriseserver")
atoms.update(self.codenamebits("redhatenterpriseserver",
codename))
atoms.update(self.releasebits("redhatenterpriseserver",
release))
elif (distro_id == 'rhel' and
'workstation' in distro.name().lower()):
atoms.add("redhatenterpriseworkstation")
atoms.update(self.codenamebits("redhatenterpriseworkstation",
codename))
atoms.update(self.releasebits("redhatenterpriseworkstation",
release))
elif "amzn" in distro_id:
atoms.add("amazonami")
atoms.update(self.codenamebits("amazonami", codename))
atoms.update(self.releasebits("amazonami", release))
elif "amazonami" in distro_id:
atoms.add("amzn")
atoms.update(self.codenamebits("amzn", codename))
atoms.update(self.releasebits("amzn", release))
elif "opensuse" in distro_id:
# just short alias
atoms.add("opensuse")
atoms.update(self.codenamebits("opensuse", codename))
atoms.update(self.releasebits("opensuse", release))
atoms.add("opensuseproject")
atoms.update(self.codenamebits("opensuseproject", codename))
atoms.update(self.releasebits("opensuseproject", release))
elif "sles" in distro_id:
atoms.add("suselinux")
atoms.update(self.codenamebits("suselinux", codename))
atoms.update(self.releasebits("suselinux", release))
elif "suselinux" in distro_id:
atoms.add("sles")
atoms.update(self.codenamebits("sles", codename))
atoms.update(self.releasebits("sles", release))
# Family aliases
if 'suse' in distro_id or distro_id == 'sles':
atoms.add("suse")
else:
atoms.add("redhat")
atoms.add("rpm")
self.platform = Rpm()
elif distro_id in ["gentoo"]:
atoms.add("emerge")
self.platform = Emerge()
elif distro_id in ["arch"]:
atoms.add("pacman")
self.platform = Pacman()
elif distro_id in ["alpine"]:
atoms.add("apk")
self.platform = Apk()
else:
self.platform = Unknown()
return ["platform:%s" % (atom,) for atom in sorted(atoms)]
def linux_distribution():
return (name(), version(), codename())
class Requirement():
"""
Requirement parser
"""
_parser = None
_lookup: Dict[str, str] = dict(
distro_codename=distro.codename(),
distro_id=distro.id(),
distro_like=distro.like(),
distro_name=distro.name(),
distro_version=distro.version(),
os_name=os.name,
platform_machine=platform.machine(),
platform_python_implementation=platform.python_implementation(),
platform_release=platform.release(),
platform_system=platform.system(),
platform_version=platform.version(),
platform_full_version=platform.python_version(),
python_version=platform.python_version()[:3],
sys_platform=sys.platform)
def __init__(self, s):
self._parser = parsley.makeGrammar(
GRAMMAR, {"lookup": self._lookup.__getitem__})
self._parsed_requirement = self._parser(s).specification()
@property
def name(self):
"""
Get the name part of the requirement
"""
return self._parsed_requirement[0]
@property
def extra(self):
"""
Get the extras from the requirement
"""
return self._parsed_requirement[1]
@property
def version_evals(self):
"""
Return the version evaluations for the requirement if present
"""
if not self._parsed_requirement[2]:
return []
return self._parsed_requirement[2]
@property
def env_evals(self):
"""
Return any environment evaluations for the requirement
"""
if not self._parsed_requirement[3]:
return []
return self._parsed_requirement[3]
@property
def env_matches(self):
"""
Determine if the current env matches the requirement
Returns
-------
True if it matches
"""
env_evals = list(self.env_evals)
env_evals = self.evaluate_matches(env_evals)
if len(env_evals) == 3:
env_evals = [self.evaluate(*env_evals)]
return False not in env_evals
def evaluate_matches(self, env_evals):
"""
Evaluate all of the statements and return a list of the results
Parameters
----------
env_evals: evals to be evaluated
Returns
-------
Evaluates all the statements and return the ones that match
"""
for element_num in range(len(env_evals)): # pylint: disable=consider-using-enumerate
entry = env_evals[element_num]
if isinstance(entry, str):
continue
operation, val1, val2 = entry
env_evals[element_num] = self.evaluate(operation, val1, val2)
return env_evals
def evaluate(self, operation, val1, val2):
"""Evaluate"""
if isinstance(val1, tuple):
val1 = self.evaluate(*val1)
if isinstance(val2, tuple):
val2 = self.evaluate(*val2)
if isinstance(val1, str):
val1 = pkg_resources.parse_version(val1)
if isinstance(val2, str):
val2 = pkg_resources.parse_version(val2)
# statement = f'{val1} {operation} {val2}'
result = None
if operation == '>':
result = val1 > val2
elif operation == '<':
result = val1 < val2
elif operation == '>=':
result = val1 >= val2
elif operation == '<=':
result = val1 <= val2
elif operation == '==':
result = val1 == val2
elif operation in ['!', '!=']:
result = val1 != val2
elif operation == 'and':
result = val1 and val2
elif operation == 'or':
result = val1 or val2
else:
logger.error(f'Invalid operation {operation}')
# logger.debug(f'Evaluated {statement} == {result}')
return result
class RepoError(Exception):
""" Exception from this module."""
def __init__(self, *args, code=1, **kwargs):
"""Exception with a source object
Arguments:
code (:obj:`int`, optional, default=1): Exception error code.
"""
super().__init__(*args, **kwargs)
self.code = code
try:
import distro
DISTRO_CODENAME = distro.codename()
except ImportError:
DISTRO_CODENAME = 'linux'
class AptSourceType(Enum):
""" Helper Enum to simplify saving data. """
BINARY = "deb"
SOURCE = "deb-src"
class AptSourceEnabled(Enum):
""" Helper Enum to translate between bool data and the Deb822 format. """
TRUE = 'yes'
FALSE = 'no'
def get_codename():
codename = distro.codename()
if not codename:
codename = "UNKNOWN"
return codename
