mirror of
https://github.com/spalencsar/bearhub.git
synced 2026-07-08 16:44:16 +02:00
AUR bearhub: fix stale source cache collision (pkgrel=10)
Use tag-specific tarball name bearhub-0.10.7-bearhub.6.tar.gz so makepkg and AUR helpers do not reuse an outdated bearhub-0.10.7.tar.gz from cache. Ignore makepkg artifacts under packaging/aur/.
This commit is contained in:
Sebastian Palencsar
@@ -1,31 +0,0 @@
|
||||
import os
|
||||
from typing import Optional
|
||||
|
||||
from bauh.api.paths import CONFIG_DIR, TEMP_DIR, CACHE_DIR, get_temp_dir
|
||||
from bauh.commons import resource
|
||||
|
||||
ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
|
||||
ARCH_CACHE_DIR = f'{CACHE_DIR}/arch'
|
||||
CATEGORIES_FILE_PATH = f'{ARCH_CACHE_DIR}/categories.txt'
|
||||
URL_CATEGORIES_FILE = 'https://raw.githubusercontent.com/vinifmor/bauh-files/master/arch/categories.txt'
|
||||
URL_GPG_SERVERS = 'https://raw.githubusercontent.com/vinifmor/bauh-files/master/arch/gpgservers.txt'
|
||||
ARCH_CONFIG_DIR = f'{CONFIG_DIR}/arch'
|
||||
CUSTOM_MAKEPKG_FILE = f'{ARCH_CONFIG_DIR}/makepkg.conf'
|
||||
AUR_INDEX_FILE = f'{ARCH_CACHE_DIR}/aur/index.txt'
|
||||
AUR_INDEX_TS_FILE = f'{ARCH_CACHE_DIR}/aur/index.ts'
|
||||
CONFIG_FILE = f'{CONFIG_DIR}/arch.yml'
|
||||
UPDATES_IGNORED_FILE = f'{ARCH_CONFIG_DIR}/updates_ignored.txt'
|
||||
EDITABLE_PKGBUILDS_FILE = f'{ARCH_CONFIG_DIR}/aur/editable_pkgbuilds.txt'
|
||||
IGNORED_REBUILD_CHECK_FILE = f'{ARCH_CONFIG_DIR}/aur/ignored_rebuild_check.txt'
|
||||
|
||||
|
||||
def get_pkgbuild_dir(user: Optional[str] = None) -> str:
|
||||
return f'{get_temp_dir(user) if user else TEMP_DIR}/arch'
|
||||
|
||||
|
||||
def get_icon_path() -> str:
|
||||
return resource.get_path('img/arch.svg', ROOT_DIR)
|
||||
|
||||
|
||||
def get_repo_icon_path() -> str:
|
||||
return resource.get_path('img/repo.svg', ROOT_DIR)
|
||||
@@ -1,316 +0,0 @@
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import urllib.parse
|
||||
from typing import Set, List, Iterable, Dict, Optional, Generator, Tuple
|
||||
|
||||
import requests
|
||||
|
||||
from bauh.api.http import HttpClient
|
||||
from bauh.gems.arch import AUR_INDEX_FILE, git
|
||||
from bauh.gems.arch.exceptions import PackageNotFoundException
|
||||
|
||||
URL_INFO = 'https://aur.archlinux.org/rpc/?v=5&type=info&'
|
||||
URL_SRC_INFO = 'https://aur.archlinux.org/cgit/aur.git/plain/.SRCINFO?h='
|
||||
URL_SEARCH = 'https://aur.archlinux.org/rpc/?v=5&type=search&arg='
|
||||
URL_INDEX = 'https://aur.archlinux.org/packages.gz'
|
||||
|
||||
RE_SRCINFO_KEYS = re.compile(r'(\w+)\s+=\s+(.+)\n')
|
||||
RE_SPLIT_DEP = re.compile(r'[<>]?=')
|
||||
|
||||
KNOWN_LIST_FIELDS = ('validpgpkeys',
|
||||
'checkdepends',
|
||||
'checkdepends_x86_64',
|
||||
'checkdepends_i686',
|
||||
'depends',
|
||||
'depends_x86_64',
|
||||
'depends_i686',
|
||||
'optdepends',
|
||||
'optdepends_x86_64',
|
||||
'optdepends_i686',
|
||||
'sha256sums',
|
||||
'sha256sums_x86_64',
|
||||
'sha512sums',
|
||||
'sha512sums_x86_64',
|
||||
'source',
|
||||
'source_x86_64',
|
||||
'source_i686',
|
||||
'makedepends',
|
||||
'makedepends_x86_64',
|
||||
'makedepends_i686',
|
||||
'provides',
|
||||
'conflicts')
|
||||
|
||||
|
||||
def map_srcinfo(string: str, pkgname: Optional[str], fields: Set[str] = None) -> dict:
|
||||
subinfos, subinfo = [], {}
|
||||
|
||||
key_fields = {'pkgname', 'pkgbase'}
|
||||
|
||||
for field in RE_SRCINFO_KEYS.findall(string):
|
||||
key = field[0].strip()
|
||||
val = field[1].strip()
|
||||
|
||||
if subinfo and key in key_fields:
|
||||
subinfos.append(subinfo)
|
||||
subinfo = {key: val}
|
||||
elif not fields or key in fields:
|
||||
if key not in subinfo:
|
||||
subinfo[key] = {val} if key in KNOWN_LIST_FIELDS else val
|
||||
else:
|
||||
if not isinstance(subinfo[key], set):
|
||||
subinfo[key] = {subinfo[key]}
|
||||
|
||||
subinfo[key].add(val)
|
||||
|
||||
if subinfo:
|
||||
subinfos.append(subinfo)
|
||||
|
||||
pkgnames = {s['pkgname'] for s in subinfos if 'pkgname' in s}
|
||||
return merge_subinfos(subinfos=subinfos,
|
||||
pkgname=None if (not pkgname or len(pkgnames) == 1 or pkgname not in pkgnames) else pkgname,
|
||||
fields=fields)
|
||||
|
||||
|
||||
def merge_subinfos(subinfos: List[dict], pkgname: Optional[str] = None, fields: Optional[Set[str]] = None) -> dict:
|
||||
info = {}
|
||||
for subinfo in subinfos:
|
||||
if not pkgname or subinfo.get('pkgname') in {None, pkgname}:
|
||||
for key, val in subinfo.items():
|
||||
if not fields or key in fields:
|
||||
current_val = info.get(key)
|
||||
|
||||
if current_val is None:
|
||||
info[key] = val
|
||||
else:
|
||||
if not isinstance(current_val, set):
|
||||
current_val = {current_val}
|
||||
info[key] = current_val
|
||||
|
||||
if isinstance(val, set):
|
||||
current_val.update(val)
|
||||
else:
|
||||
current_val.add(val)
|
||||
|
||||
for field in info.keys():
|
||||
val = info.get(field)
|
||||
|
||||
if isinstance(val, set):
|
||||
info[field] = [*val]
|
||||
|
||||
return info
|
||||
|
||||
|
||||
class AURClient:
|
||||
|
||||
def __init__(self, http_client: HttpClient, logger: logging.Logger, x86_64: bool):
|
||||
self.http_client = http_client
|
||||
self.logger = logger
|
||||
self.x86_64 = x86_64
|
||||
self.srcinfo_cache = {}
|
||||
|
||||
def search(self, words: str) -> dict:
|
||||
return self.http_client.get_json(URL_SEARCH + words)
|
||||
|
||||
def get_info(self, names: Iterable[str]) -> Optional[List[dict]]:
|
||||
if names:
|
||||
try:
|
||||
res = self.http_client.get_json(URL_INFO + self._map_names_as_queries(names))
|
||||
except requests.exceptions.ConnectionError:
|
||||
self.logger.warning('Could not retrieve installed AUR packages API data. It seems the internet connection is off.')
|
||||
return
|
||||
|
||||
if res is None:
|
||||
self.logger.warning("Call to AUR API's info endpoint has failed")
|
||||
return
|
||||
|
||||
error = res.get('error')
|
||||
|
||||
if error:
|
||||
self.logger.warning(f"AUR API's info endpoint returned an unexpected error: {error}")
|
||||
return
|
||||
|
||||
results = res.get('results')
|
||||
|
||||
if results is not None:
|
||||
return results
|
||||
|
||||
self.logger.warning(f"AUR API's info endpoint returned an unexpected response: {res}")
|
||||
|
||||
def map_provided(self, pkgname: str, pkgver: str, provided: Optional[Iterable[str]] = None, strip_epoch: bool = True) -> Set[str]:
|
||||
all_provided = {pkgname, f"{pkgname}={pkgver.split('-')[0] if strip_epoch else pkgver}"}
|
||||
|
||||
if provided:
|
||||
for provided in provided:
|
||||
all_provided.add(provided)
|
||||
all_provided.add(provided.split('=', 1)[0])
|
||||
|
||||
return all_provided
|
||||
|
||||
def gen_updates_data(self, names: Iterable[str]) -> Generator[Tuple[str, dict], None, None]:
|
||||
pkgs_info = self.get_info(names)
|
||||
|
||||
if pkgs_info:
|
||||
for package in pkgs_info:
|
||||
pkgname, pkgver = package['Name'], package['Version'].split('-')[0]
|
||||
|
||||
deps = set()
|
||||
|
||||
for dtype in ('Depends', 'MakeDepends', 'CheckDepends'):
|
||||
dep_set = package.get(dtype)
|
||||
if dep_set:
|
||||
deps.update(dep_set)
|
||||
|
||||
conflicts = set()
|
||||
pkg_conflicts = package.get('Conflicts')
|
||||
|
||||
if pkg_conflicts:
|
||||
conflicts.update(pkg_conflicts)
|
||||
|
||||
yield pkgname, {
|
||||
'v': pkgver,
|
||||
'b': package.get('PackageBase', pkgname),
|
||||
'r': 'aur',
|
||||
'p': self.map_provided(pkgname=pkgname, pkgver=pkgver, provided=package.get('Provides'), strip_epoch=False),
|
||||
'd': deps,
|
||||
'c': conflicts,
|
||||
'ds': None,
|
||||
's': None}
|
||||
|
||||
def get_src_info(self, name: str, real_name: Optional[str] = None) -> dict:
|
||||
srcinfo = self.srcinfo_cache.get(name)
|
||||
|
||||
if srcinfo:
|
||||
return srcinfo
|
||||
|
||||
res = self.http_client.get(URL_SRC_INFO + urllib.parse.quote(name))
|
||||
|
||||
if res and res.text:
|
||||
srcinfo = map_srcinfo(string=res.text, pkgname=real_name if real_name else name)
|
||||
|
||||
if srcinfo:
|
||||
self.srcinfo_cache[name] = srcinfo
|
||||
|
||||
return srcinfo
|
||||
|
||||
self.logger.warning('No .SRCINFO found for {}'.format(name))
|
||||
self.logger.info('Checking if {} is based on another package'.format(name))
|
||||
# if was not found, it may be based on another package.
|
||||
infos = self.get_info((name,))
|
||||
|
||||
if infos:
|
||||
info = infos[0]
|
||||
|
||||
info_name = info.get('Name')
|
||||
info_base = info.get('PackageBase')
|
||||
if info_name and info_base and info_name != info_base:
|
||||
self.logger.info('{p} is based on {b}. Retrieving {b} .SRCINFO'.format(p=info_name, b=info_base))
|
||||
srcinfo = self.get_src_info(name=info_base, real_name=info_name)
|
||||
|
||||
if srcinfo:
|
||||
self.srcinfo_cache[name] = srcinfo
|
||||
|
||||
return srcinfo
|
||||
|
||||
def extract_required_dependencies(self, srcinfo: dict) -> Set[str]:
|
||||
deps = set()
|
||||
|
||||
for attr in ('makedepends',
|
||||
'makedepends_{}'.format('x86_64' if self.x86_64 else 'i686'),
|
||||
'depends',
|
||||
'depends_{}'.format('x86_64' if self.x86_64 else 'i686'),
|
||||
'checkdepends',
|
||||
'checkdepends_{}'.format('x86_64' if self.x86_64 else 'i686')):
|
||||
|
||||
if srcinfo.get(attr):
|
||||
deps.update(srcinfo[attr])
|
||||
|
||||
return deps
|
||||
|
||||
def get_required_dependencies(self, name: str) -> Set[str]:
|
||||
info = self.get_src_info(name)
|
||||
|
||||
if not info:
|
||||
raise PackageNotFoundException(name)
|
||||
|
||||
return self.extract_required_dependencies(info)
|
||||
|
||||
def _map_names_as_queries(self, names: Iterable[str]) -> str:
|
||||
return '&'.join((f'arg[]={urllib.parse.quote(n)}' for n in names))
|
||||
|
||||
def read_local_index(self) -> dict:
|
||||
self.logger.info('Checking if the cached AUR index file exists')
|
||||
if os.path.exists(AUR_INDEX_FILE):
|
||||
self.logger.info('Reading AUR index file from {}'.format(AUR_INDEX_FILE))
|
||||
index = {}
|
||||
with open(AUR_INDEX_FILE) as f:
|
||||
for l in f.readlines():
|
||||
if l:
|
||||
lsplit = l.split('=')
|
||||
index[lsplit[0]] = lsplit[1].strip()
|
||||
self.logger.info("AUR index file read")
|
||||
return index
|
||||
self.logger.warning('The AUR index file was not found')
|
||||
|
||||
def download_names(self) -> Set[str]:
|
||||
self.logger.info('Downloading AUR index')
|
||||
try:
|
||||
res = self.http_client.get(URL_INDEX)
|
||||
|
||||
if res and res.text:
|
||||
return {n.strip() for n in res.text.split('\n') if n and not n.startswith('#')}
|
||||
else:
|
||||
self.logger.warning('No data returned from: {}'.format(URL_INDEX))
|
||||
except requests.exceptions.ConnectionError:
|
||||
self.logger.warning('No internet connection: could not pre-index packages')
|
||||
|
||||
self.logger.info("Finished")
|
||||
|
||||
def read_index(self) -> Iterable[str]:
|
||||
try:
|
||||
index = self.read_local_index()
|
||||
|
||||
if not index:
|
||||
self.logger.warning("Cached AUR index file not found")
|
||||
pkgnames = self.download_names()
|
||||
|
||||
if pkgnames:
|
||||
return pkgnames
|
||||
else:
|
||||
self.logger.warning("Could not load AUR index on the context")
|
||||
return set()
|
||||
else:
|
||||
return index.values()
|
||||
except Exception:
|
||||
return set()
|
||||
|
||||
def clean_caches(self):
|
||||
self.srcinfo_cache.clear()
|
||||
|
||||
def map_update_data(self, pkgname: str, latest_version: Optional[str] = None, srcinfo: Optional[dict] = None) -> dict:
|
||||
info = self.get_src_info(pkgname) if not srcinfo else srcinfo
|
||||
|
||||
provided = set()
|
||||
provided.add(pkgname)
|
||||
|
||||
if info:
|
||||
provided.add(f"{pkgname}={info['pkgver']}")
|
||||
if info.get('provides'):
|
||||
provided.update(info.get('provides'))
|
||||
|
||||
return {'c': info.get('conflicts'), 's': None, 'p': provided, 'r': 'aur',
|
||||
'v': info['pkgver'], 'd': self.extract_required_dependencies(info),
|
||||
'b': info.get('pkgbase', pkgname)}
|
||||
else:
|
||||
if latest_version:
|
||||
provided.add(f'{pkgname}={latest_version}')
|
||||
|
||||
return {'c': None, 's': None, 'p': provided, 'r': 'aur', 'v': latest_version, 'd': set(), 'b': pkgname}
|
||||
|
||||
def fill_update_data(self, output: Dict[str, dict], pkgname: str, latest_version: str, srcinfo: dict = None):
|
||||
data = self.map_update_data(pkgname=pkgname, latest_version=latest_version, srcinfo=srcinfo)
|
||||
output[pkgname] = data
|
||||
|
||||
|
||||
def is_supported(arch_config: dict) -> bool:
|
||||
return arch_config['aur'] and git.is_installed()
|
||||
@@ -1,45 +0,0 @@
|
||||
from typing import Optional
|
||||
|
||||
from bauh.commons.config import YAMLConfigManager
|
||||
from bauh.gems.arch import CONFIG_FILE, get_pkgbuild_dir
|
||||
|
||||
|
||||
def get_build_dir(arch_config: dict, user: Optional[str]) -> str:
|
||||
build_dir = arch_config.get('aur_build_dir')
|
||||
|
||||
if not build_dir:
|
||||
build_dir = get_pkgbuild_dir(user)
|
||||
|
||||
return build_dir
|
||||
|
||||
|
||||
class ArchConfigManager(YAMLConfigManager):
|
||||
|
||||
def __init__(self):
|
||||
super(ArchConfigManager, self).__init__(config_file_path=CONFIG_FILE)
|
||||
|
||||
def get_default_config(self) -> dict:
|
||||
return {'optimize': True,
|
||||
"sync_databases": True,
|
||||
"clean_cached": True,
|
||||
'aur': True,
|
||||
'repositories': True,
|
||||
"refresh_mirrors_startup": False,
|
||||
"sync_databases_startup": True,
|
||||
'mirrors_sort_limit': 5,
|
||||
'repositories_mthread_download': False,
|
||||
'automatch_providers': True,
|
||||
'edit_aur_pkgbuild': False,
|
||||
'aur_build_dir': None,
|
||||
'aur_remove_build_dir': True,
|
||||
'aur_build_only_chosen': True,
|
||||
'check_dependency_breakage': True,
|
||||
'suggest_unneeded_uninstall': False,
|
||||
'suggest_optdep_uninstall': False,
|
||||
"suggest_optdep_select": True,
|
||||
'aur_idx_exp': 1,
|
||||
'categories_exp': 24,
|
||||
'aur_rebuild_detector': False,
|
||||
"aur_rebuild_detector_no_bin": True,
|
||||
"prefer_repository_provider": True,
|
||||
'suggestions_exp': 24}
|
||||
@@ -1,152 +0,0 @@
|
||||
from io import StringIO
|
||||
from typing import Set, Tuple, Dict, Collection
|
||||
|
||||
from bauh.api.abstract.handler import ProcessWatcher
|
||||
from bauh.api.abstract.view import MultipleSelectComponent, InputOption, FormComponent, SingleSelectComponent, \
|
||||
SelectViewType
|
||||
from bauh.commons import resource
|
||||
from bauh.commons.html import bold
|
||||
from bauh.commons.view_utils import get_human_size_str
|
||||
from bauh.gems.arch import ROOT_DIR, get_repo_icon_path, get_icon_path, pacman
|
||||
from bauh.view.util.translation import I18n
|
||||
|
||||
def _get_repo_icon(repository: str):
|
||||
return resource.get_path('img/{}.svg'.format('arch' if repository == 'aur' else 'repo'), ROOT_DIR)
|
||||
|
||||
|
||||
def request_optional_deps(pkgname: str, pkg_repos: dict, watcher: ProcessWatcher, i18n: I18n, is_optdep_download: bool) -> Set[str]:
|
||||
opts = []
|
||||
|
||||
repo_deps = [p for p, data in pkg_repos.items() if data['repository'] != 'aur']
|
||||
sizes = pacman.map_update_sizes(repo_deps) if repo_deps else {}
|
||||
|
||||
for p, d in pkg_repos.items():
|
||||
size = sizes.get(p)
|
||||
label = f"{p} ({i18n['repository']}: {d['repository'].lower()}) | " \
|
||||
f"{i18n['size'].capitalize()}: {get_human_size_str(size) if size is not None else '?'}"
|
||||
op = InputOption(label=label, value=p, tooltip=d.get('desc') or None)
|
||||
op.icon_path = _get_repo_icon(d['repository'])
|
||||
opts.append(op)
|
||||
|
||||
view_opts = MultipleSelectComponent(label='',
|
||||
options=opts,
|
||||
default_options=set(opts) if is_optdep_download else None)
|
||||
|
||||
msg = f"<p>{i18n['arch.install.optdeps.request.success'].format(pkg=bold(pkgname))}</p>" \
|
||||
f"<p>{i18n['arch.install.optdeps.request.body']}:</p>"
|
||||
|
||||
install = watcher.request_confirmation(title=i18n['arch.install.optdeps.request.title'],
|
||||
body=msg,
|
||||
components=[view_opts],
|
||||
confirmation_label=i18n['install'].capitalize(),
|
||||
deny_label=i18n['do_not.install'].capitalize(),
|
||||
min_width=600,
|
||||
min_height=200)
|
||||
|
||||
if install:
|
||||
return {o.value for o in view_opts.values}
|
||||
|
||||
|
||||
def confirm_missing_deps(deps: Collection[Tuple[str, str]], watcher: ProcessWatcher, i18n: I18n) -> bool:
|
||||
opts = []
|
||||
|
||||
total_isize, total_dsize = None, None
|
||||
pkgs_data = pacman.map_updates_data(pkgs=tuple(d[0] for d in deps if d[1] != 'aur'), description=True) or dict()
|
||||
|
||||
for dep in deps:
|
||||
ver, desc, isize, dsize = None, None, None, None
|
||||
data = pkgs_data.get(dep[0])
|
||||
|
||||
if data:
|
||||
desc, isize, dsize = (data.get(f) for f in ('des', 's', 'ds'))
|
||||
|
||||
if isize is not None:
|
||||
if total_isize is None:
|
||||
total_isize = 0
|
||||
|
||||
total_isize += isize
|
||||
|
||||
if dsize is not None:
|
||||
if total_dsize is None:
|
||||
total_dsize = 0
|
||||
|
||||
total_dsize += dsize
|
||||
|
||||
label = f"{dep[0]} | " \
|
||||
f"{i18n['size'].capitalize()}: {get_human_size_str(isize) if isize is not None else '?'}" \
|
||||
f"{' ({}: {})'.format(i18n['download'].capitalize(), get_human_size_str(dsize)) if dsize else ''}"
|
||||
|
||||
op = InputOption(label=label, value=dep[0], tooltip=desc)
|
||||
op.read_only = True
|
||||
op.icon_path = _get_repo_icon(dep[1])
|
||||
opts.append(op)
|
||||
|
||||
comp = MultipleSelectComponent(label='', options=opts, default_options=set(opts))
|
||||
|
||||
body = StringIO()
|
||||
body.write('<p>')
|
||||
body.write(i18n['arch.missing_deps.body'].format(deps=bold(str(len(deps)))))
|
||||
|
||||
if total_isize is not None or total_dsize is not None:
|
||||
body.write(' (')
|
||||
|
||||
if total_isize is not None:
|
||||
body.write(f"{i18n['size'].capitalize()}: {bold(get_human_size_str(total_isize))} | ")
|
||||
|
||||
if total_dsize is not None:
|
||||
body.write(f"{i18n['download'].capitalize()}: {bold(get_human_size_str(total_dsize))}")
|
||||
|
||||
body.write(')')
|
||||
|
||||
body.write(':</p>')
|
||||
|
||||
return watcher.request_confirmation(title=i18n['arch.missing_deps.title'],
|
||||
body=body.getvalue(),
|
||||
components=[comp],
|
||||
confirmation_label=i18n['continue'].capitalize(),
|
||||
deny_label=i18n['cancel'].capitalize(),
|
||||
min_width=625)
|
||||
|
||||
|
||||
def request_providers(providers_map: Dict[str, Set[str]], repo_map: Dict[str, str], watcher: ProcessWatcher, i18n: I18n) -> Set[str]:
|
||||
msg = "<p>{}.</p><p>{}.</p>".format(i18n['arch.dialog.providers.line1'],
|
||||
i18n['arch.dialog.providers.line2'])
|
||||
|
||||
repo_icon_path = get_repo_icon_path()
|
||||
aur_icon_path = get_icon_path()
|
||||
|
||||
form = FormComponent([], label='')
|
||||
|
||||
for dep, providers in providers_map.items():
|
||||
opts = []
|
||||
|
||||
repo_providers, aur_providers = {}, {}
|
||||
|
||||
for p in providers:
|
||||
repo = repo_map.get(p, 'aur')
|
||||
|
||||
if repo == 'aur':
|
||||
aur_providers[p] = repo
|
||||
else:
|
||||
repo_providers[p] = repo
|
||||
|
||||
for current_providers in (repo_providers, aur_providers):
|
||||
for pname, repo in sorted(current_providers.items()):
|
||||
opts.append(InputOption(label=pname,
|
||||
value=pname,
|
||||
icon_path=aur_icon_path if repo == 'aur' else repo_icon_path,
|
||||
tooltip='{}: {}'.format(i18n['repository'].capitalize(), repo)))
|
||||
|
||||
form.components.append(SingleSelectComponent(label=bold(dep.lower()),
|
||||
options=opts,
|
||||
default_option=opts[0],
|
||||
type_=SelectViewType.COMBO,
|
||||
max_per_line=1))
|
||||
|
||||
if watcher.request_confirmation(title=i18n['arch.providers'].capitalize(),
|
||||
body=msg,
|
||||
components=[form],
|
||||
confirmation_label=i18n['proceed'].capitalize(),
|
||||
deny_label=i18n['cancel'].capitalize()):
|
||||
|
||||
return {s.get_selected() for s in form.components if isinstance(s, SingleSelectComponent)}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,92 +0,0 @@
|
||||
import multiprocessing
|
||||
import os
|
||||
import shutil
|
||||
import traceback
|
||||
from logging import Logger
|
||||
from pathlib import Path
|
||||
from typing import Optional, Set, Tuple, Dict
|
||||
|
||||
from bauh.api.paths import TEMP_DIR
|
||||
from bauh.commons.system import new_root_subprocess
|
||||
|
||||
|
||||
def supports_performance_mode() -> bool:
|
||||
return os.path.exists('/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor')
|
||||
|
||||
|
||||
def current_governors() -> Dict[str, Set[int]]:
|
||||
governors = {}
|
||||
for cpu in range(multiprocessing.cpu_count()):
|
||||
with open(f'/sys/devices/system/cpu/cpu{cpu}/cpufreq/scaling_governor') as f:
|
||||
gov = f.read().strip()
|
||||
cpus = governors.get(gov, set())
|
||||
cpus.add(cpu)
|
||||
governors[gov] = cpus
|
||||
|
||||
return governors
|
||||
|
||||
|
||||
def set_governor(governor: str, root_password: Optional[str], logger: Logger, cpu_idxs: Optional[Set[int]] = None):
|
||||
new_gov_file = f'{TEMP_DIR}/bauh_scaling_governor'
|
||||
|
||||
try:
|
||||
Path(TEMP_DIR).mkdir(exist_ok=True, parents=True)
|
||||
except OSError:
|
||||
logger.error(f"Could not create temporary directory for changing CPU governor: {TEMP_DIR}")
|
||||
return
|
||||
|
||||
try:
|
||||
with open(new_gov_file, 'w+') as f:
|
||||
f.write(governor)
|
||||
except OSError:
|
||||
logger.error(f"Could not write new governor ({governor}) to {new_gov_file}")
|
||||
return
|
||||
|
||||
for idx in (cpu_idxs if cpu_idxs else range(multiprocessing.cpu_count())):
|
||||
_change_governor(idx, new_gov_file, root_password)
|
||||
|
||||
if os.path.exists(new_gov_file):
|
||||
try:
|
||||
os.remove(new_gov_file)
|
||||
except OSError:
|
||||
logger.error(f"Could not remove temporary governor file ({new_gov_file})")
|
||||
|
||||
|
||||
def _change_governor(cpu_idx: int, new_gov_file_path: str, root_password: Optional[str]):
|
||||
try:
|
||||
gov_file = f'/sys/devices/system/cpu/cpu{cpu_idx}/cpufreq/scaling_governor'
|
||||
replace = new_root_subprocess((shutil.which('cp'), new_gov_file_path, gov_file), root_password=root_password)
|
||||
replace.wait()
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
|
||||
|
||||
def set_all_cpus_to(governor: str, root_password: Optional[str], logger: Logger) \
|
||||
-> Tuple[bool, Optional[Dict[str, Set[int]]]]:
|
||||
cpus_changed, cpu_governors = False, current_governors()
|
||||
|
||||
if cpu_governors:
|
||||
not_in_performance = set()
|
||||
for gov, cpus in cpu_governors.items():
|
||||
if gov != governor:
|
||||
not_in_performance.update(cpus)
|
||||
|
||||
if not_in_performance:
|
||||
if logger:
|
||||
logger.info(f"Changing CPUs {not_in_performance} governors to '{governor}'")
|
||||
|
||||
set_governor(governor=governor, root_password=root_password, logger=logger, cpu_idxs=not_in_performance)
|
||||
cpus_changed = True
|
||||
|
||||
return cpus_changed, cpu_governors
|
||||
|
||||
|
||||
def set_cpus(governors: Dict[str, Set[int]], root_password: Optional[str], logger: Logger,
|
||||
ignore_governors: Optional[Set[str]] = None):
|
||||
|
||||
for gov, cpus in governors.items():
|
||||
if not ignore_governors or gov not in ignore_governors:
|
||||
if logger:
|
||||
logger.info(f"Changing CPUs {cpus} governors to '{gov}'")
|
||||
|
||||
set_governor(governor=gov, root_password=root_password, logger=logger, cpu_idxs=cpus)
|
||||
@@ -1,53 +0,0 @@
|
||||
import logging
|
||||
import os
|
||||
import time
|
||||
import traceback
|
||||
from datetime import datetime
|
||||
from logging import Logger
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
from bauh.api.paths import CACHE_DIR
|
||||
from bauh.commons.system import ProcessHandler
|
||||
|
||||
SYNC_FILE = f'{CACHE_DIR}/arch/db_sync'
|
||||
|
||||
|
||||
def should_sync(arch_config: dict, aur_supported: bool, handler: Optional[ProcessHandler], logger: logging.Logger):
|
||||
if aur_supported or arch_config['repositories']:
|
||||
if os.path.exists(SYNC_FILE):
|
||||
with open(SYNC_FILE) as f:
|
||||
sync_file = f.read()
|
||||
|
||||
try:
|
||||
sync_time = datetime.fromtimestamp(int(sync_file))
|
||||
now = datetime.now()
|
||||
|
||||
if now > sync_time and now.day != sync_time.day:
|
||||
logger.info("Package databases synchronization out of date")
|
||||
else:
|
||||
msg = "Package databases already synchronized"
|
||||
logger.info(msg)
|
||||
if handler:
|
||||
handler.watcher.print(msg)
|
||||
return False
|
||||
except Exception:
|
||||
logger.warning("Could not convert the database synchronization time from '{}".format(SYNC_FILE))
|
||||
traceback.print_exc()
|
||||
return True
|
||||
else:
|
||||
msg = "Package databases synchronization disabled"
|
||||
if handler:
|
||||
handler.watcher.print(msg)
|
||||
logger.info(msg)
|
||||
return False
|
||||
|
||||
|
||||
def register_sync(logger: Logger):
|
||||
try:
|
||||
Path('/'.join(SYNC_FILE.split('/')[0:-1])).mkdir(parents=True, exist_ok=True)
|
||||
with open(SYNC_FILE, 'w+') as f:
|
||||
f.write(str(int(time.time())))
|
||||
except Exception:
|
||||
logger.error("Could not write to database sync file '{}'".format(SYNC_FILE))
|
||||
traceback.print_exc()
|
||||
@@ -1,675 +0,0 @@
|
||||
import re
|
||||
import traceback
|
||||
from logging import Logger
|
||||
from threading import Thread
|
||||
from typing import Set, List, Tuple, Dict, Iterable, Optional, Generator, Pattern
|
||||
|
||||
from bauh.api.abstract.handler import ProcessWatcher
|
||||
from bauh.commons.version_util import match_required_version
|
||||
from bauh.gems.arch import pacman, message, sorting, confirmation
|
||||
from bauh.gems.arch.aur import AURClient
|
||||
from bauh.gems.arch.exceptions import PackageNotFoundException
|
||||
from bauh.view.util.translation import I18n
|
||||
|
||||
|
||||
class DependenciesAnalyser:
|
||||
|
||||
_re_dep_operator: Optional[Pattern] = None
|
||||
|
||||
def __init__(self, aur_client: AURClient, i18n: I18n, logger: Logger):
|
||||
self.aur_client = aur_client
|
||||
self.i18n = i18n
|
||||
self._log = logger
|
||||
|
||||
@classmethod
|
||||
def re_dep_operator(cls) -> Pattern:
|
||||
if not cls._re_dep_operator:
|
||||
cls._re_dep_operator = re.compile(r'([<>=]+)')
|
||||
|
||||
return cls._re_dep_operator
|
||||
|
||||
def _fill_repository(self, name: str, output: List[Tuple[str, str]]):
|
||||
|
||||
repository = pacman.read_repository_from_info(name)
|
||||
|
||||
if repository:
|
||||
output.append((name, repository))
|
||||
return
|
||||
|
||||
guess = pacman.guess_repository(name)
|
||||
|
||||
if guess:
|
||||
output.append(guess)
|
||||
return
|
||||
|
||||
aur_info = self.aur_client.get_src_info(name)
|
||||
|
||||
if aur_info:
|
||||
output.append((name, 'aur'))
|
||||
return
|
||||
|
||||
output.append((name, ''))
|
||||
|
||||
def get_missing_packages(self, names: Set[str], repository: Optional[str] = None, in_analysis: Optional[Set[str]] = None) -> \
|
||||
List[Tuple[str, str]]:
|
||||
"""
|
||||
:param names:
|
||||
:param repository:
|
||||
:param in_analysis: global set storing all names in analysis to avoid repeated recursion
|
||||
:return:
|
||||
"""
|
||||
global_in_analysis = in_analysis if in_analysis else set()
|
||||
|
||||
missing_names = pacman.check_missing({n for n in names if n not in in_analysis})
|
||||
|
||||
if missing_names:
|
||||
missing_root = []
|
||||
threads = []
|
||||
|
||||
if not repository:
|
||||
for name in missing_names:
|
||||
t = Thread(target=self._fill_repository, args=(name, missing_root), daemon=True)
|
||||
t.start()
|
||||
threads.append(t)
|
||||
|
||||
for t in threads:
|
||||
t.join()
|
||||
|
||||
threads.clear()
|
||||
|
||||
# checking if there is any unknown dependency:
|
||||
for rdep in missing_root:
|
||||
if not rdep[1]:
|
||||
return missing_root
|
||||
else:
|
||||
global_in_analysis.add(rdep[0])
|
||||
else:
|
||||
for missing in missing_names:
|
||||
missing_root.append((missing, repository))
|
||||
global_in_analysis.add(missing)
|
||||
|
||||
missing_sub = []
|
||||
for rdep in missing_root:
|
||||
subdeps = self.aur_client.get_required_dependencies(rdep[0]) if rdep[1] == 'aur' else pacman.read_dependencies(rdep[0])
|
||||
subdeps_not_analysis = {sd for sd in subdeps if sd not in global_in_analysis}
|
||||
|
||||
if subdeps_not_analysis:
|
||||
missing_subdeps = self.get_missing_packages(subdeps_not_analysis, in_analysis=global_in_analysis)
|
||||
|
||||
# checking if there is any unknown:
|
||||
if missing_subdeps:
|
||||
for subdep in missing_subdeps:
|
||||
if not subdep[0]:
|
||||
return [*missing_subdeps, *missing_root]
|
||||
|
||||
if subdep[0] not in missing_names:
|
||||
missing_sub.append(subdep)
|
||||
return [*missing_sub, *missing_root]
|
||||
|
||||
def get_missing_subdeps_of(self, names: Set[str], repository: str) -> List[Tuple[str, str]]:
|
||||
missing = []
|
||||
already_added = {*names}
|
||||
in_analyses = {*names}
|
||||
|
||||
for name in names:
|
||||
subdeps = self.aur_client.get_required_dependencies(name) if repository == 'aur' else pacman.read_dependencies(name)
|
||||
|
||||
if subdeps:
|
||||
missing_subdeps = self.get_missing_packages(subdeps, in_analysis=in_analyses)
|
||||
|
||||
if missing_subdeps:
|
||||
for subdep in missing_subdeps: # checking if there is any unknown:
|
||||
if subdep[0] not in already_added:
|
||||
missing.append(subdep)
|
||||
|
||||
if not subdep[0]:
|
||||
return missing
|
||||
return missing
|
||||
|
||||
def get_missing_subdeps(self, name: str, repository: str, srcinfo: dict = None) -> List[Tuple[str, str]]:
|
||||
missing = []
|
||||
already_added = {name}
|
||||
in_analyses = {name}
|
||||
|
||||
if repository == 'aur':
|
||||
subdeps = self.aur_client.get_required_dependencies(name) if not srcinfo else self.aur_client.extract_required_dependencies(srcinfo)
|
||||
else:
|
||||
subdeps = pacman.read_dependencies(name)
|
||||
|
||||
if subdeps:
|
||||
missing_subdeps = self.get_missing_packages(subdeps, in_analysis=in_analyses)
|
||||
|
||||
if missing_subdeps:
|
||||
for subdep in missing_subdeps: # checking if there is any unknown:
|
||||
if subdep[0] not in already_added:
|
||||
missing.append(subdep)
|
||||
|
||||
if not subdep[0]:
|
||||
return missing
|
||||
return missing
|
||||
|
||||
def map_known_missing_deps(self, known_deps: Dict[str, str], watcher: ProcessWatcher, check_subdeps: bool = True) -> Optional[List[Tuple[str, str]]]:
|
||||
sorted_deps = [] # it will hold the proper order to install the missing dependencies
|
||||
|
||||
repo_deps, aur_deps = set(), set()
|
||||
|
||||
for dep, repo in known_deps.items():
|
||||
if repo == 'aur':
|
||||
aur_deps.add(dep)
|
||||
else:
|
||||
repo_deps.add(dep)
|
||||
|
||||
if check_subdeps:
|
||||
for deps in ((repo_deps, 'repo'), (aur_deps, 'aur')):
|
||||
if deps[0]:
|
||||
missing_subdeps = self.get_missing_subdeps_of(deps[0], deps[1])
|
||||
|
||||
if missing_subdeps:
|
||||
for dep in missing_subdeps:
|
||||
if not dep[1]:
|
||||
dependents = ', '.join(deps[0]) # it is not possible to know which is the exact dependent
|
||||
message.show_dep_not_found(dep[0], self.i18n, watcher, dependent=dependents)
|
||||
return
|
||||
|
||||
for dep in missing_subdeps:
|
||||
if dep not in sorted_deps:
|
||||
sorted_deps.append(dep)
|
||||
|
||||
for dep, repo in known_deps.items():
|
||||
if repo != 'aur':
|
||||
data = (dep, repo)
|
||||
if data not in sorted_deps:
|
||||
sorted_deps.append(data)
|
||||
|
||||
for dep in aur_deps:
|
||||
sorted_deps.append((dep, 'aur'))
|
||||
|
||||
return sorted_deps
|
||||
|
||||
def _find_repo_providers(self, dep_name: str, dep_exp: str, remote_provided_map: Dict[str, Set[str]],
|
||||
deps_data: Dict[str, dict], remote_repo_map: Dict[str, str]) -> Generator[Tuple[str, str, Optional[dict]], None, None]:
|
||||
if dep_name == dep_exp:
|
||||
providers = remote_provided_map.get(dep_name)
|
||||
|
||||
if providers:
|
||||
for pkgname in providers:
|
||||
yield pkgname, remote_repo_map.get(pkgname), None
|
||||
|
||||
else: # try to find the package through the pacman's search mechanism
|
||||
match = pacman.find_one_match(dep_name)
|
||||
|
||||
if match:
|
||||
yield match, remote_repo_map.get(match), None
|
||||
|
||||
else: # handling cases when the dep has an expression ( e.g: xpto>=0.12 )
|
||||
exact_exp_providers = remote_provided_map.get(dep_exp)
|
||||
|
||||
if exact_exp_providers:
|
||||
for p in exact_exp_providers:
|
||||
yield p, remote_repo_map.get(p), None
|
||||
else:
|
||||
providers = remote_provided_map.get(dep_name)
|
||||
|
||||
if not providers: # try to find the package through the pacman's search mechanism
|
||||
match = pacman.find_one_match(dep_name)
|
||||
|
||||
if match:
|
||||
providers = {match}
|
||||
|
||||
if providers:
|
||||
providers_no_provided_data = {p for p in providers if p not in deps_data}
|
||||
missing_providers_data = None
|
||||
|
||||
if providers_no_provided_data:
|
||||
missing_providers_data = pacman.map_updates_data(providers_no_provided_data)
|
||||
|
||||
if not missing_providers_data:
|
||||
raise Exception(f"Could not retrieve information from providers: "
|
||||
f"{', '.join(providers_no_provided_data)}")
|
||||
|
||||
data_not_found = {p for p in providers if p not in missing_providers_data}
|
||||
|
||||
if data_not_found:
|
||||
raise Exception(f"Could not retrieve information from providers: "
|
||||
f"{', '.join(data_not_found)}")
|
||||
|
||||
split_informed_dep = self.re_dep_operator().split(dep_exp)
|
||||
|
||||
version_required = split_informed_dep[2]
|
||||
exp_op = split_informed_dep[1] if split_informed_dep[1] != '=' else '=='
|
||||
|
||||
for p in providers:
|
||||
info = deps_data.get(p)
|
||||
|
||||
if not info and missing_providers_data:
|
||||
info = missing_providers_data[p]
|
||||
|
||||
for provided_exp in info['p']:
|
||||
split_dep = self.re_dep_operator().split(provided_exp)
|
||||
|
||||
if len(split_dep) == 3 and split_dep[0] == dep_name:
|
||||
version_provided = split_dep[2]
|
||||
|
||||
if match_required_version(version_provided, exp_op, version_required):
|
||||
yield p, remote_repo_map.get(p), info
|
||||
break
|
||||
|
||||
def _find_aur_providers(self, dep_name: str, dep_exp: str, aur_index: Iterable[str], exact_match: bool) -> Generator[Tuple[str, dict], None, None]:
|
||||
if exact_match and dep_name in aur_index:
|
||||
if dep_name == dep_exp:
|
||||
yield from self.aur_client.gen_updates_data((dep_name,))
|
||||
return
|
||||
else:
|
||||
for _, dep_data in self.aur_client.gen_updates_data((dep_name,)):
|
||||
split_informed_dep = self.re_dep_operator().split(dep_exp)
|
||||
version_required = split_informed_dep[2]
|
||||
exp_op = split_informed_dep[1].strip()
|
||||
|
||||
if match_required_version(dep_data['v'], exp_op, version_required):
|
||||
yield dep_name, dep_data
|
||||
return
|
||||
|
||||
aur_search = self.aur_client.search(dep_name)
|
||||
|
||||
if aur_search:
|
||||
aur_results = aur_search.get('results')
|
||||
|
||||
if aur_results:
|
||||
if dep_name == dep_exp:
|
||||
version_required, exp_op = None, None
|
||||
else:
|
||||
split_informed_dep = self.re_dep_operator().split(dep_exp)
|
||||
version_required = split_informed_dep[2]
|
||||
exp_op = split_informed_dep[1] if split_informed_dep[1] != '=' else '=='
|
||||
|
||||
for pkgname, pkgdata in self.aur_client.gen_updates_data((aur_res['Name'] for aur_res in aur_results)):
|
||||
if pkgname == dep_name or (dep_name in pkgdata['p']):
|
||||
try:
|
||||
if not version_required or match_required_version(pkgdata['v'], exp_op,
|
||||
version_required):
|
||||
yield pkgname, pkgdata
|
||||
except Exception:
|
||||
self._log.warning(f"Could not compare AUR package '{pkgname}' version '{pkgdata['v']}' "
|
||||
f"with the dependency expression '{dep_exp}'")
|
||||
traceback.print_exc()
|
||||
|
||||
def _fill_missing_dep(self, dep_name: str, dep_exp: str, aur_index: Iterable[str],
|
||||
missing_deps: Set[Tuple[str, str]],
|
||||
remote_provided_map: Dict[str, Set[str]], remote_repo_map: Dict[str, str],
|
||||
repo_deps: Set[str], aur_deps: Set[str], deps_data: Dict[str, dict], watcher: ProcessWatcher,
|
||||
automatch_providers: bool, prefer_repository_provider: bool, dependent: Optional[str] = None):
|
||||
|
||||
repo_matches = None
|
||||
|
||||
for pkgname, repo, data in self._find_repo_providers(dep_name=dep_name, dep_exp=dep_exp,
|
||||
remote_repo_map=remote_repo_map,
|
||||
remote_provided_map=remote_provided_map,
|
||||
deps_data=deps_data):
|
||||
if automatch_providers and pkgname == dep_name:
|
||||
missing_deps.add((pkgname, repo))
|
||||
repo_deps.add(pkgname)
|
||||
|
||||
if data:
|
||||
deps_data[pkgname] = data
|
||||
|
||||
return
|
||||
|
||||
if repo_matches is None:
|
||||
repo_matches = []
|
||||
|
||||
repo_matches.append((pkgname, repo, data))
|
||||
|
||||
if prefer_repository_provider and repo_matches and len(repo_matches) == 1:
|
||||
pkg_name, pkg_repo, pkg_data = repo_matches[0]
|
||||
missing_deps.add((pkg_name, pkg_repo))
|
||||
repo_deps.add(pkg_name)
|
||||
|
||||
if pkg_data:
|
||||
deps_data[pkg_name] = pkg_data
|
||||
|
||||
return
|
||||
|
||||
aur_matches = None
|
||||
|
||||
if aur_index:
|
||||
for pkgname, pkgdata in self._find_aur_providers(dep_name=dep_name, dep_exp=dep_exp, aur_index=aur_index,
|
||||
exact_match=automatch_providers):
|
||||
if automatch_providers and pkgname == dep_name:
|
||||
missing_deps.add((pkgname, 'aur'))
|
||||
aur_deps.add(pkgname)
|
||||
deps_data[pkgname] = pkgdata
|
||||
return
|
||||
|
||||
if aur_matches is None:
|
||||
aur_matches = []
|
||||
|
||||
aur_matches.append((pkgname, pkgdata))
|
||||
|
||||
total_matches = (len(repo_matches) if repo_matches else 0) + (len(aur_matches) if aur_matches else 0)
|
||||
|
||||
if total_matches == 0:
|
||||
self.__raise_dependency_not_found(dep_exp, watcher, dependent)
|
||||
elif total_matches == 1:
|
||||
if repo_matches:
|
||||
repo_pkg = [*repo_matches][0]
|
||||
|
||||
if repo_pkg[2]:
|
||||
deps_data[repo_pkg[0]] = repo_pkg[2] # already updating the deps data (if available)
|
||||
|
||||
match = (repo_pkg[0], repo_pkg[1])
|
||||
repo_deps.add(repo_pkg[0])
|
||||
else:
|
||||
aur_pkg = aur_matches[0]
|
||||
deps_data[aur_pkg[0]] = aur_pkg[1] # already updating the deps data (if available)
|
||||
aur_deps.add(aur_pkg[0])
|
||||
match = aur_pkg[0], 'aur'
|
||||
|
||||
missing_deps.add(match)
|
||||
|
||||
elif total_matches > 1:
|
||||
missing_deps.add((dep_name, '__several__'))
|
||||
|
||||
if repo_matches:
|
||||
repo_deps.add(dep_name)
|
||||
|
||||
if aur_matches:
|
||||
aur_deps.add(dep_name)
|
||||
|
||||
for pkgname, _ in aur_matches:
|
||||
for key in (dep_name, dep_exp):
|
||||
key_provided = remote_provided_map.get(key, set())
|
||||
remote_provided_map[key] = key_provided
|
||||
key_provided.add(pkgname)
|
||||
|
||||
if pkgname not in remote_repo_map:
|
||||
remote_repo_map[pkgname] = 'aur'
|
||||
|
||||
def __raise_dependency_not_found(self, dep_exp: str, watcher: Optional[ProcessWatcher], dependent: Optional[str] = None):
|
||||
if watcher:
|
||||
message.show_dep_not_found(depname=dep_exp, i18n=self.i18n, watcher=watcher, dependent=dependent)
|
||||
raise PackageNotFoundException(dep_exp)
|
||||
else:
|
||||
raise PackageNotFoundException(dep_exp)
|
||||
|
||||
def _fill_aur_updates_data(self, pkgnames: Iterable[str], output_data: dict):
|
||||
if pkgnames:
|
||||
for pkgname, pkgdata in self.aur_client.gen_updates_data(pkgnames):
|
||||
output_data[pkgname] = pkgdata
|
||||
|
||||
def map_missing_deps(self, pkgs_data: Dict[str, dict], provided_map: Dict[str, Set[str]],
|
||||
remote_provided_map: Dict[str, Set[str]], remote_repo_map: Dict[str, str],
|
||||
aur_index: Iterable[str], deps_checked: Set[str], deps_data: Dict[str, dict],
|
||||
sort: bool, watcher: ProcessWatcher, choose_providers: bool = True,
|
||||
automatch_providers: bool = False, prefer_repository_provider: bool = False) -> Optional[List[Tuple[str, str]]]:
|
||||
sorted_deps = [] # it will hold the proper order to install the missing dependencies
|
||||
|
||||
missing_deps, repo_missing, aur_missing = set(), set(), set()
|
||||
|
||||
deps_checked.update(pkgs_data.keys())
|
||||
|
||||
for p, data in pkgs_data.items():
|
||||
if data['d']:
|
||||
for dep in data['d']:
|
||||
if dep in pkgs_data:
|
||||
continue
|
||||
if dep not in provided_map:
|
||||
dep_split = self.re_dep_operator().split(dep)
|
||||
dep_name = dep_split[0].strip()
|
||||
|
||||
if dep_name not in deps_checked:
|
||||
deps_checked.add(dep_name)
|
||||
|
||||
if dep_name not in provided_map:
|
||||
self._fill_missing_dep(dep_name=dep_name, dep_exp=dep, aur_index=aur_index,
|
||||
missing_deps=missing_deps,
|
||||
remote_provided_map=remote_provided_map,
|
||||
remote_repo_map=remote_repo_map,
|
||||
repo_deps=repo_missing, aur_deps=aur_missing, watcher=watcher,
|
||||
deps_data=deps_data,
|
||||
automatch_providers=automatch_providers,
|
||||
prefer_repository_provider=prefer_repository_provider,
|
||||
dependent=p)
|
||||
else:
|
||||
version_pattern = '{}='.format(dep_name)
|
||||
version_found = [p for p in provided_map if p.startswith(version_pattern)]
|
||||
|
||||
if version_found:
|
||||
version_found = version_found[0].split('=')[1]
|
||||
version_required = dep_split[2]
|
||||
op = dep_split[1].strip()
|
||||
|
||||
if not match_required_version(version_found, op, version_required):
|
||||
self._fill_missing_dep(dep_name=dep_name, dep_exp=dep, aur_index=aur_index,
|
||||
missing_deps=missing_deps,
|
||||
remote_provided_map=remote_provided_map,
|
||||
remote_repo_map=remote_repo_map,
|
||||
repo_deps=repo_missing, aur_deps=aur_missing,
|
||||
watcher=watcher,
|
||||
deps_data=deps_data,
|
||||
automatch_providers=automatch_providers,
|
||||
prefer_repository_provider=prefer_repository_provider,
|
||||
dependent=p)
|
||||
else:
|
||||
self._fill_missing_dep(dep_name=dep_name, dep_exp=dep, aur_index=aur_index,
|
||||
missing_deps=missing_deps,
|
||||
remote_provided_map=remote_provided_map,
|
||||
remote_repo_map=remote_repo_map,
|
||||
repo_deps=repo_missing, aur_deps=aur_missing,
|
||||
watcher=watcher,
|
||||
deps_data=deps_data,
|
||||
automatch_providers=automatch_providers,
|
||||
prefer_repository_provider=prefer_repository_provider,
|
||||
dependent=p)
|
||||
|
||||
if missing_deps:
|
||||
self._fill_single_providers_data(missing_deps, repo_missing, aur_missing, deps_data)
|
||||
|
||||
missing_subdeps = self.map_missing_deps(pkgs_data={**deps_data}, provided_map=provided_map,
|
||||
aur_index=aur_index, deps_checked=deps_checked, sort=False,
|
||||
deps_data=deps_data, watcher=watcher,
|
||||
remote_provided_map=remote_provided_map,
|
||||
remote_repo_map=remote_repo_map,
|
||||
automatch_providers=automatch_providers,
|
||||
choose_providers=False,
|
||||
prefer_repository_provider=prefer_repository_provider)
|
||||
|
||||
if missing_subdeps:
|
||||
missing_deps.update(missing_subdeps)
|
||||
|
||||
if sort:
|
||||
sorted_deps.extend(sorting.sort(deps_data.keys(), deps_data))
|
||||
else:
|
||||
sorted_deps.extend(((dep[0], dep[1]) for dep in missing_deps))
|
||||
|
||||
if sorted_deps and choose_providers:
|
||||
return self.fill_providers_deps(missing_deps=sorted_deps, provided_map=provided_map,
|
||||
remote_provided_map=remote_provided_map, remote_repo_map=remote_repo_map,
|
||||
watcher=watcher, sort=sort, already_checked=deps_checked,
|
||||
aur_idx=aur_index, deps_data=deps_data,
|
||||
automatch_providers=automatch_providers,
|
||||
prefer_repository_provider=prefer_repository_provider)
|
||||
|
||||
return sorted_deps
|
||||
|
||||
def _fill_single_providers_data(self, all_missing_deps: Iterable[Tuple[str, str]], repo_missing_deps: Iterable[str], aur_missing_deps: Iterable[str], deps_data: Dict[str, dict]):
|
||||
"""
|
||||
fills the missing data of the single dependency providers since they are already considered dependencies
|
||||
(when several providers are available for given a dependency, the user must choose first)
|
||||
"""
|
||||
repo_providers_no_data, aur_providers_no_data = None, None
|
||||
|
||||
for dep_name, dep_repo in all_missing_deps:
|
||||
if dep_repo == '__several__':
|
||||
deps_data[dep_name] = {'d': None, 'p': {dep_name}, 'r': dep_repo}
|
||||
elif dep_name not in deps_data:
|
||||
if repo_missing_deps and dep_name in repo_missing_deps:
|
||||
if repo_providers_no_data is None:
|
||||
repo_providers_no_data = set()
|
||||
|
||||
repo_providers_no_data.add(dep_name)
|
||||
elif aur_missing_deps and dep_name in aur_missing_deps:
|
||||
if aur_providers_no_data is None:
|
||||
aur_providers_no_data = set()
|
||||
|
||||
aur_providers_no_data.add(dep_name)
|
||||
|
||||
aur_data_filler, aur_providers_data = None, None
|
||||
|
||||
if aur_providers_no_data:
|
||||
aur_providers_data = dict()
|
||||
aur_data_filler = Thread(target=self._fill_aur_updates_data,
|
||||
args=(aur_providers_no_data, aur_providers_data),
|
||||
daemon=True)
|
||||
aur_data_filler.start()
|
||||
|
||||
if repo_providers_no_data:
|
||||
repo_providers_data = pacman.map_updates_data(repo_providers_no_data)
|
||||
|
||||
if repo_providers_data:
|
||||
deps_data.update(repo_providers_data)
|
||||
|
||||
if aur_data_filler:
|
||||
aur_data_filler.join()
|
||||
|
||||
if aur_providers_data:
|
||||
deps_data.update(aur_providers_data)
|
||||
|
||||
def fill_providers_deps(self, missing_deps: List[Tuple[str, str]],
|
||||
provided_map: Dict[str, Set[str]], remote_repo_map: Dict[str, str],
|
||||
already_checked: Set[str], remote_provided_map: Dict[str, Set[str]],
|
||||
deps_data: Dict[str, dict], aur_idx: Iterable[str], sort: bool,
|
||||
watcher: ProcessWatcher, automatch_providers: bool,
|
||||
prefer_repository_provider: bool) -> Optional[List[Tuple[str, str]]]:
|
||||
"""
|
||||
:param missing_deps:
|
||||
:param provided_map:
|
||||
:param remote_repo_map:
|
||||
:param already_checked:
|
||||
:param remote_provided_map:
|
||||
:param deps_data:
|
||||
:param aur_idx:
|
||||
:param sort:
|
||||
:param watcher:
|
||||
:param automatch_providers
|
||||
:param prefer_repository_provider
|
||||
:return: all deps sorted or None if the user declined the providers options
|
||||
"""
|
||||
|
||||
deps_providers = map_providers({data[0] for data in missing_deps if data[1] == '__several__'},
|
||||
remote_provided_map)
|
||||
|
||||
if deps_providers:
|
||||
providers_repos = {}
|
||||
repos_providers = set()
|
||||
|
||||
for providers in deps_providers.values():
|
||||
for provider in providers:
|
||||
if remote_repo_map.get(provider) == 'aur':
|
||||
providers_repos[provider] = 'aur'
|
||||
else:
|
||||
repos_providers.add(provider)
|
||||
|
||||
providers_repos.update(pacman.map_repositories(repos_providers))
|
||||
selected_providers = confirmation.request_providers(deps_providers, providers_repos, watcher, self.i18n)
|
||||
|
||||
if not selected_providers:
|
||||
return
|
||||
else:
|
||||
# adding the chosen providers for re-checking the missing dependencies
|
||||
repo_selected, aur_selected = set(), set()
|
||||
|
||||
for provider in selected_providers:
|
||||
if provider in repos_providers:
|
||||
repo_selected.add(provider)
|
||||
else:
|
||||
aur_selected.add(provider)
|
||||
|
||||
providers_data = dict()
|
||||
|
||||
if repo_selected:
|
||||
providers_data.update(pacman.map_updates_data(repo_selected))
|
||||
# adding the providers as "installed" packages
|
||||
provided_map.update(pacman.map_provided(remote=True, pkgs=repo_selected))
|
||||
|
||||
if aur_selected:
|
||||
for pkgname, pkgdata in self.aur_client.gen_updates_data(aur_selected):
|
||||
providers_data[pkgname] = pkgdata
|
||||
for provider in pkgdata['p']: # adding the providers as "installed" packages
|
||||
currently_provided = provided_map.get(provider, set())
|
||||
provided_map[provider] = currently_provided
|
||||
currently_provided.add(pkgname)
|
||||
|
||||
providers_deps = self.map_missing_deps(pkgs_data=providers_data,
|
||||
provided_map=provided_map,
|
||||
aur_index=aur_idx,
|
||||
deps_checked=already_checked,
|
||||
deps_data=deps_data,
|
||||
sort=False,
|
||||
remote_provided_map=remote_provided_map,
|
||||
remote_repo_map=remote_repo_map,
|
||||
watcher=watcher,
|
||||
choose_providers=True,
|
||||
automatch_providers=automatch_providers,
|
||||
prefer_repository_provider=prefer_repository_provider)
|
||||
|
||||
if providers_deps is None: # it means the user called off the installation process
|
||||
return
|
||||
|
||||
# cleaning the already mapped providers deps:
|
||||
to_remove = []
|
||||
|
||||
for idx, dep in enumerate(missing_deps):
|
||||
if dep[1] == '__several__':
|
||||
to_remove.append(idx)
|
||||
|
||||
for idx, to_remove in enumerate(to_remove):
|
||||
del missing_deps[to_remove - idx]
|
||||
|
||||
missing_deps.extend(((p, providers_repos.get(p, 'aur')) for p in selected_providers))
|
||||
|
||||
for dep in providers_deps:
|
||||
if dep not in missing_deps and dep[1] != '__several__':
|
||||
missing_deps.append(dep)
|
||||
|
||||
deps_data.update(providers_data)
|
||||
|
||||
if not self.fill_providers_deps(missing_deps=missing_deps, provided_map=provided_map,
|
||||
remote_repo_map=remote_repo_map, already_checked=already_checked,
|
||||
aur_idx=aur_idx, remote_provided_map=remote_provided_map,
|
||||
deps_data=deps_data, sort=False, watcher=watcher,
|
||||
automatch_providers=automatch_providers,
|
||||
prefer_repository_provider=prefer_repository_provider):
|
||||
return
|
||||
|
||||
if sort:
|
||||
missing_to_sort = {d[0] for d in missing_deps if d[1] != '__several__'}
|
||||
return sorting.sort(missing_to_sort, deps_data, provided_map)
|
||||
|
||||
return missing_deps
|
||||
|
||||
def map_all_required_by(self, pkgnames: Iterable[str], to_ignore: Set[str]) -> Set[str]:
|
||||
if pkgnames:
|
||||
to_ignore.update(pkgnames)
|
||||
|
||||
all_requirements = {r for reqs in pacman.map_required_by(pkgnames).values() for r in reqs if r not in to_ignore}
|
||||
|
||||
if all_requirements:
|
||||
sub_requirements = self.map_all_required_by(all_requirements, to_ignore)
|
||||
|
||||
if sub_requirements:
|
||||
all_requirements.update(sub_requirements)
|
||||
return all_requirements
|
||||
|
||||
return all_requirements
|
||||
|
||||
|
||||
def map_providers(pkgs: Iterable[str], remote_provided_map: Dict[str, Set[str]]) -> Dict[str, Set[str]]:
|
||||
res = {}
|
||||
|
||||
for p in pkgs:
|
||||
providers = remote_provided_map.get(p)
|
||||
|
||||
if providers and len(providers) > 1:
|
||||
res[p] = providers
|
||||
|
||||
return res
|
||||
@@ -1,128 +0,0 @@
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
from pathlib import Path
|
||||
from typing import List, Dict, Tuple, Optional, Callable
|
||||
|
||||
from bauh.gems.arch import pacman
|
||||
from bauh.gems.arch.model import ArchPackage
|
||||
|
||||
RE_DESKTOP_ENTRY = re.compile(r'[\n^](Exec|Icon|NoDisplay)\s*=\s*(.+)')
|
||||
RE_CLEAN_NAME = re.compile(r'[+*?%]')
|
||||
|
||||
|
||||
def write_several(pkgs: Dict[str, ArchPackage], overwrite: bool = True, maintainer: str = None, after_desktop_files: Optional[Callable] = None, after_written: Optional[Callable[[str], None]] = None) -> int:
|
||||
if overwrite:
|
||||
to_cache = {p.name for p in pkgs.values()}
|
||||
else:
|
||||
to_cache = {p.name for p in pkgs.values() if not os.path.exists(p.get_disk_cache_path())}
|
||||
|
||||
desktop_files = pacman.map_desktop_files(*to_cache)
|
||||
|
||||
if after_desktop_files:
|
||||
after_desktop_files()
|
||||
|
||||
if not desktop_files:
|
||||
for pkgname in to_cache:
|
||||
write(pkg=pkgs[pkgname], maintainer=maintainer, after_written=after_written)
|
||||
|
||||
return len(to_cache)
|
||||
else:
|
||||
for pkgname in to_cache:
|
||||
pkgfiles = desktop_files.get(pkgname)
|
||||
|
||||
if not pkgfiles:
|
||||
write(pkg=pkgs[pkgname], maintainer=maintainer, after_written=after_written)
|
||||
else:
|
||||
desktop_entry = find_best_desktop_entry(pkgname, pkgfiles)
|
||||
|
||||
if desktop_entry:
|
||||
write(pkg=pkgs[pkgname], maintainer=maintainer, after_written=after_written,
|
||||
desktop_file=desktop_entry[0], command=desktop_entry[1], icon=desktop_entry[2])
|
||||
else:
|
||||
write(pkg=pkgs[pkgname], maintainer=maintainer, after_written=after_written)
|
||||
|
||||
return len(to_cache)
|
||||
|
||||
|
||||
def find_best_desktop_entry(pkgname: str, desktop_files: List[str]) -> Optional[Tuple[str, str, str]]:
|
||||
if len(desktop_files) == 1:
|
||||
exec_icon = read_desktop_exec_and_icon(pkgname, desktop_files[0])
|
||||
|
||||
if exec_icon:
|
||||
return desktop_files[0], exec_icon[0], exec_icon[1]
|
||||
else:
|
||||
# trying to find the exact name match:
|
||||
for dfile in desktop_files:
|
||||
if dfile.endswith('{}.desktop'.format(pkgname)):
|
||||
exec_icon = read_desktop_exec_and_icon(pkgname, dfile)
|
||||
|
||||
if exec_icon:
|
||||
return dfile, exec_icon[0], exec_icon[1]
|
||||
|
||||
# trying to find a close name match:
|
||||
clean_name = RE_CLEAN_NAME.sub('', pkgname)
|
||||
for dfile in desktop_files:
|
||||
if dfile.endswith('{}.desktop'.format(clean_name)):
|
||||
exec_icon = read_desktop_exec_and_icon(clean_name, dfile)
|
||||
|
||||
if exec_icon:
|
||||
return dfile, exec_icon[0], exec_icon[1]
|
||||
|
||||
# finding any match:
|
||||
for dfile in desktop_files:
|
||||
exec_icon = read_desktop_exec_and_icon(pkgname, dfile)
|
||||
|
||||
if exec_icon:
|
||||
return dfile, exec_icon[0], exec_icon[1]
|
||||
|
||||
|
||||
def read_desktop_exec_and_icon(pkgname: str, desktop_file: str) -> Optional[Tuple[str, str]]:
|
||||
if os.path.isfile(desktop_file):
|
||||
with open(desktop_file) as f:
|
||||
possibilities = set()
|
||||
|
||||
content = f.read()
|
||||
cmd, icon = None, None
|
||||
for field in RE_DESKTOP_ENTRY.findall(content):
|
||||
if field[0] == 'Exec':
|
||||
cmd = field[1].strip().replace('"', '')
|
||||
elif field[0] == 'Icon':
|
||||
icon = field[1].strip()
|
||||
elif field[0] == 'NoDisplay' and field[1].strip().lower() == 'true':
|
||||
cmd, icon = None, None
|
||||
|
||||
if cmd and icon:
|
||||
possibilities.add((cmd, icon))
|
||||
cmd, icon = None, None
|
||||
|
||||
if possibilities:
|
||||
if len(possibilities) == 1:
|
||||
return [*possibilities][0]
|
||||
else:
|
||||
# trying to find the exact name x command match
|
||||
for p in possibilities:
|
||||
if p[0].startswith('{} '.format(pkgname)):
|
||||
return p
|
||||
|
||||
return sorted(possibilities)[0] # returning any possibility
|
||||
|
||||
|
||||
def write(pkg: ArchPackage, desktop_file: Optional[str] = None, command: Optional[str] = None,
|
||||
icon: Optional[str] = None, maintainer: Optional[str] = None, after_written: Optional[callable] = None):
|
||||
pkg.desktop_entry = desktop_file
|
||||
pkg.command = command
|
||||
pkg.icon_path = icon
|
||||
|
||||
if maintainer and not pkg.maintainer:
|
||||
pkg.maintainer = maintainer
|
||||
|
||||
Path(pkg.get_disk_cache_path()).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
data = pkg.get_data_to_cache()
|
||||
|
||||
with open(pkg.get_disk_data_path(), 'w+') as f:
|
||||
f.write(json.dumps(data))
|
||||
|
||||
if after_written:
|
||||
after_written(pkg.name)
|
||||
@@ -1,195 +0,0 @@
|
||||
import glob
|
||||
import logging
|
||||
import os
|
||||
import time
|
||||
import traceback
|
||||
from threading import Lock, Thread
|
||||
from typing import List, Iterable, Dict, Optional
|
||||
|
||||
from bauh.api.abstract.download import FileDownloader
|
||||
from bauh.api.abstract.handler import ProcessWatcher
|
||||
from bauh.api.abstract.view import MessageType
|
||||
from bauh.api.http import HttpClient
|
||||
from bauh.commons.html import bold
|
||||
from bauh.commons.system import ProcessHandler, SimpleProcess
|
||||
from bauh.gems.arch import pacman
|
||||
from bauh.view.util.translation import I18n
|
||||
|
||||
|
||||
class ArchDownloadException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class CacheDirCreationException(ArchDownloadException):
|
||||
pass
|
||||
|
||||
|
||||
class MultiThreadedDownloader:
|
||||
|
||||
def __init__(self, file_downloader: FileDownloader, http_client: HttpClient, mirrors_available: Iterable[str],
|
||||
mirrors_branch: str, cache_dir: str, logger: logging.Logger):
|
||||
self.downloader = file_downloader
|
||||
self.http_client = http_client
|
||||
self.mirrors = mirrors_available
|
||||
self.branch = mirrors_branch
|
||||
self.extensions = ['.tar.zst', '.tar.xz']
|
||||
self.cache_dir = cache_dir
|
||||
self.logger = logger
|
||||
self.async_downloads = []
|
||||
self.async_downloads_lock = Lock()
|
||||
|
||||
def download_package_signature(self, pkg: dict, file_url: str, output_path: str, root_password: Optional[str], watcher: ProcessWatcher):
|
||||
try:
|
||||
self.logger.info("Downloading package '{}' signature".format(pkg['n']))
|
||||
|
||||
sig_downloaded = self.downloader.download(file_url=file_url + '.sig', watcher=None,
|
||||
output_path=output_path + '.sig',
|
||||
cwd='.', root_password=root_password,
|
||||
display_file_size=False,
|
||||
max_threads=1)
|
||||
|
||||
if not sig_downloaded:
|
||||
msg = "Could not download package '{}' signature".format(pkg['n'])
|
||||
self.logger.warning(msg)
|
||||
watcher.print('[warning] {}'.format(msg))
|
||||
else:
|
||||
msg = "Package '{}' signature successfully downloaded".format(pkg['n'])
|
||||
self.logger.info(msg)
|
||||
watcher.print(msg)
|
||||
except Exception:
|
||||
self.logger.warning("An error occurred while download package '{}' signature".format(pkg['n']))
|
||||
traceback.print_exc()
|
||||
|
||||
def download_package(self, pkg: Dict[str, str], root_password: Optional[str], substatus_prefix: str, watcher: ProcessWatcher, size: int) -> bool:
|
||||
if self.mirrors and self.branch:
|
||||
pkgname = '{}-{}{}.pkg'.format(pkg['n'], pkg['v'], ('-{}'.format(pkg['a']) if pkg['a'] else ''))
|
||||
|
||||
if {f for f in glob.glob(self.cache_dir + '/*') if f.split('/')[-1].startswith(pkgname)}:
|
||||
watcher.print("{} ({}) file found o cache dir {}. Skipping download.".format(pkg['n'], pkg['v'], self.cache_dir))
|
||||
return True
|
||||
|
||||
arch = pkg['a'] if pkg.get('a') and pkg['a'] != 'any' else 'x86_64'
|
||||
|
||||
url_base = '{}/{}/{}/{}'.format(self.branch, pkg['r'], arch, pkgname)
|
||||
base_output_path = '{}/{}'.format(self.cache_dir, pkgname)
|
||||
|
||||
for mirror in self.mirrors:
|
||||
for ext in self.extensions:
|
||||
url = '{}{}{}'.format(mirror, url_base, ext)
|
||||
output_path = base_output_path + ext
|
||||
|
||||
watcher.print("Downloading '{}' from mirror '{}'".format(pkgname, mirror))
|
||||
|
||||
pkg_downloaded = self.downloader.download(file_url=url, watcher=watcher, output_path=output_path,
|
||||
cwd='.', root_password=root_password, display_file_size=True,
|
||||
substatus_prefix=substatus_prefix,
|
||||
known_size=size)
|
||||
if not pkg_downloaded:
|
||||
watcher.print("Could not download '{}' from mirror '{}'".format(pkgname, mirror))
|
||||
else:
|
||||
self.logger.info("Package '{}' successfully downloaded".format(pkg['n']))
|
||||
t = Thread(target=self.download_package_signature,
|
||||
args=(pkg, url, output_path, root_password, watcher),
|
||||
daemon=True)
|
||||
t.start()
|
||||
self.async_downloads_lock.acquire()
|
||||
self.async_downloads.append(t)
|
||||
self.async_downloads_lock.release()
|
||||
return True
|
||||
return False
|
||||
|
||||
def wait_for_async_downloads(self):
|
||||
self.async_downloads_lock.acquire()
|
||||
|
||||
try:
|
||||
if self.async_downloads:
|
||||
for t in self.async_downloads:
|
||||
t.join()
|
||||
|
||||
self.async_downloads.clear()
|
||||
finally:
|
||||
self.async_downloads_lock.release()
|
||||
|
||||
|
||||
class MultithreadedDownloadService:
|
||||
|
||||
def __init__(self, file_downloader: FileDownloader, http_client: HttpClient, logger: logging.Logger, i18n: I18n):
|
||||
self.file_downloader = file_downloader
|
||||
self.http_client = http_client
|
||||
self.logger = logger
|
||||
self.i18n = i18n
|
||||
|
||||
def download_packages(self, pkgs: List[str], handler: ProcessHandler, root_password: Optional[str], sizes: Dict[str, int] = None) -> int:
|
||||
ti = time.time()
|
||||
watcher = handler.watcher
|
||||
mirrors = pacman.list_available_mirrors()
|
||||
|
||||
if not mirrors:
|
||||
self.logger.warning('repository mirrors seem to be not reachable')
|
||||
watcher.print('[warning] repository mirrors seem to be not reachable')
|
||||
watcher.print('[warning] multi-threaded download cancelled')
|
||||
return 0
|
||||
|
||||
branch = pacman.get_mirrors_branch()
|
||||
|
||||
if not branch:
|
||||
self.logger.warning('no default repository branch found')
|
||||
watcher.print('[warning] no default repository branch found')
|
||||
watcher.print('[warning] multi-threaded download cancelled')
|
||||
return 0
|
||||
|
||||
cache_dir = pacman.get_cache_dir()
|
||||
|
||||
if not os.path.exists(cache_dir):
|
||||
success, _ = handler.handle_simple(SimpleProcess(['mkdir', '-p', cache_dir], root_password=root_password))
|
||||
|
||||
if not success:
|
||||
msg = "could not create cache dir '{}'".format(cache_dir)
|
||||
self.logger.warning(msg)
|
||||
watcher.print("[warning] {}".format(cache_dir))
|
||||
watcher.show_message(title=self.i18n['warning'].capitalize(),
|
||||
body=self.i18n['arch.mthread_downloaded.error.cache_dir'].format(bold(cache_dir)),
|
||||
type_=MessageType.WARNING)
|
||||
raise CacheDirCreationException()
|
||||
|
||||
downloader = MultiThreadedDownloader(file_downloader=self.file_downloader,
|
||||
mirrors_available=mirrors,
|
||||
mirrors_branch=branch,
|
||||
http_client=self.http_client,
|
||||
logger=self.logger,
|
||||
cache_dir=cache_dir)
|
||||
|
||||
downloaded = 0
|
||||
pkgs_data = pacman.list_download_data(pkgs)
|
||||
|
||||
if not pkgs_data:
|
||||
error_msg = "Could not retrieve download data of the following packages: {}".format(', '.join(pkgs))
|
||||
watcher.print(error_msg)
|
||||
self.logger.error(error_msg)
|
||||
return 0
|
||||
|
||||
for pkg in pkgs_data:
|
||||
self.logger.info('Preparing to download package: {} ({})'.format(pkg['n'], pkg['v']))
|
||||
try:
|
||||
perc = '({0:.2f}%)'.format((downloaded / (2 * len(pkgs))) * 100)
|
||||
status_prefix = '{} [{}/{}]'.format(perc, downloaded + 1, len(pkgs))
|
||||
|
||||
if downloader.download_package(pkg=pkg,
|
||||
root_password=root_password,
|
||||
watcher=handler.watcher,
|
||||
substatus_prefix=status_prefix,
|
||||
size=sizes.get(pkg['n']) if sizes else None):
|
||||
downloaded += 1
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
watcher.show_message(title=self.i18n['error'].capitalize(),
|
||||
body=self.i18n['arch.mthread_downloaded.error.cancelled'],
|
||||
type_=MessageType.ERROR)
|
||||
raise ArchDownloadException()
|
||||
|
||||
self.logger.info("Waiting for signature downloads to complete")
|
||||
downloader.wait_for_async_downloads()
|
||||
self.logger.info("Signature downloads finished")
|
||||
tf = time.time()
|
||||
self.logger.info("Download time: {0:.2f} seconds".format(tf - ti))
|
||||
return downloaded
|
||||
@@ -1,13 +0,0 @@
|
||||
from typing import Optional
|
||||
|
||||
|
||||
class PackageNotFoundException(Exception):
|
||||
|
||||
def __init__(self, name: str):
|
||||
self.name = name
|
||||
|
||||
|
||||
class PackageInHoldException(Exception):
|
||||
|
||||
def __init__(self, name: Optional[str] = None):
|
||||
self.name = name
|
||||
@@ -1,58 +0,0 @@
|
||||
import shutil
|
||||
from io import StringIO
|
||||
from logging import Logger
|
||||
from typing import List, Tuple, Optional
|
||||
|
||||
from bauh.commons import system
|
||||
from bauh.commons.system import SimpleProcess
|
||||
|
||||
|
||||
def is_installed() -> bool:
|
||||
return bool(shutil.which('git'))
|
||||
|
||||
|
||||
def list_commits(proj_dir: str, limit: int = -1, logger: Optional[Logger] = None) -> Optional[List[Tuple[str, int]]]:
|
||||
if limit == 0:
|
||||
return
|
||||
|
||||
cmd = StringIO()
|
||||
cmd.write('git log --format="%H %ct"')
|
||||
|
||||
if limit > 0:
|
||||
cmd.write(f' -{limit}')
|
||||
|
||||
code, output = system.execute(cmd.getvalue(), cwd=proj_dir, shell=True)
|
||||
|
||||
if code == 0 and output:
|
||||
commits = []
|
||||
for line in output.split('\n'):
|
||||
line_strip = line.strip()
|
||||
|
||||
if line_strip:
|
||||
line_split = line_strip.split(' ', 1)
|
||||
|
||||
if len(line_split) == 2:
|
||||
commit_sha = line_split[0].strip()
|
||||
try:
|
||||
commit_date = int(line_split[1].strip())
|
||||
except ValueError:
|
||||
commit_date = None
|
||||
|
||||
if logger:
|
||||
logger.error(f"Could not parse commit date {line_split[1]}")
|
||||
|
||||
commits.append((commit_sha, commit_date))
|
||||
|
||||
return commits
|
||||
|
||||
|
||||
def clone(url: str, target_dir: Optional[str], depth: int = -1, custom_user: Optional[str] = None) -> SimpleProcess:
|
||||
cmd = ['git', 'clone', url]
|
||||
|
||||
if depth > 0:
|
||||
cmd.append(f'--depth={depth}')
|
||||
|
||||
if target_dir:
|
||||
cmd.append(target_dir)
|
||||
|
||||
return SimpleProcess(cmd=cmd, custom_user=custom_user)
|
||||
@@ -1,14 +0,0 @@
|
||||
from typing import Optional
|
||||
|
||||
from bauh.commons.system import SystemProcess, new_subprocess
|
||||
|
||||
|
||||
def receive_key(key: str, server: Optional[str] = None) -> SystemProcess:
|
||||
cmd = ['gpg']
|
||||
|
||||
if server:
|
||||
cmd.extend(['--keyserver', server])
|
||||
|
||||
cmd.extend(['--recv-key', key])
|
||||
|
||||
return SystemProcess(new_subprocess(cmd), check_error_output=False)
|
||||
@@ -1,90 +0,0 @@
|
||||
import os
|
||||
import re
|
||||
from typing import Optional, Set, Tuple
|
||||
|
||||
from bauh.commons import system
|
||||
from bauh.commons.system import ProcessHandler, SimpleProcess
|
||||
from bauh.gems.arch import CUSTOM_MAKEPKG_FILE
|
||||
from bauh.gems.arch.proc_util import write_as_user
|
||||
|
||||
RE_UNKNOWN_GPG_KEY = re.compile(r'\(unknown public key (\w+)\)')
|
||||
RE_DEPS_PATTERN = re.compile(r'\n?\s+->\s(.+)\n')
|
||||
|
||||
|
||||
def gen_srcinfo(build_dir: str, custom_pkgbuild_path: Optional[str] = None, custom_user: Optional[str] = None) -> str:
|
||||
cmd = f"makepkg --printsrcinfo{' -p {}'.format(custom_pkgbuild_path) if custom_pkgbuild_path else ''}"
|
||||
return system.run_cmd(cmd, cwd=build_dir, custom_user=custom_user)
|
||||
|
||||
|
||||
def update_srcinfo(project_dir: str, custom_user: Optional[str] = None) -> bool:
|
||||
updated_src = system.run_cmd('makepkg --printsrcinfo', cwd=project_dir, custom_user=custom_user)
|
||||
|
||||
if updated_src:
|
||||
return write_as_user(content=updated_src, file_path=f"{project_dir}/.SRCINFO", user=custom_user)
|
||||
|
||||
return False
|
||||
|
||||
|
||||
def list_output_files(project_dir: str, custom_pkgbuild_path: Optional[str] = None,
|
||||
custom_user: Optional[str] = None) -> Set[str]:
|
||||
cmd = f"makepkg --packagelist{' -p {}'.format(custom_pkgbuild_path) if custom_pkgbuild_path else ''}"
|
||||
output = system.run_cmd(cmd=cmd, print_error=False, cwd=project_dir, custom_user=custom_user)
|
||||
|
||||
if output:
|
||||
return {p.strip() for p in output.split('\n') if p}
|
||||
|
||||
return set()
|
||||
|
||||
|
||||
def build(pkgdir: str, optimize: bool, handler: ProcessHandler, custom_pkgbuild: Optional[str] = None,
|
||||
custom_user: Optional[str] = None) -> Tuple[bool, str]:
|
||||
cmd = ['makepkg', '-ALcsmf', '--skipchecksums', '--nodeps']
|
||||
|
||||
if custom_pkgbuild:
|
||||
cmd.append('-p')
|
||||
cmd.append(custom_pkgbuild)
|
||||
|
||||
if optimize:
|
||||
if os.path.exists(CUSTOM_MAKEPKG_FILE):
|
||||
handler.watcher.print(f'Using custom makepkg.conf -> {CUSTOM_MAKEPKG_FILE}')
|
||||
cmd.append(f'--config={CUSTOM_MAKEPKG_FILE}')
|
||||
else:
|
||||
handler.watcher.print(f'Custom optimized makepkg.conf ({CUSTOM_MAKEPKG_FILE}) not found')
|
||||
|
||||
return handler.handle_simple(SimpleProcess(cmd, cwd=pkgdir, shell=True, custom_user=custom_user))
|
||||
|
||||
|
||||
def check(project_dir: str, optimize: bool, missing_deps: bool, handler: ProcessHandler,
|
||||
custom_pkgbuild: Optional[str] = None, custom_user: Optional[str] = None) -> dict:
|
||||
res = {}
|
||||
|
||||
cmd = ['makepkg', '-ALcfm', '--check', '--noarchive', '--nobuild', '--noprepare']
|
||||
|
||||
if not missing_deps:
|
||||
cmd.append('--nodeps')
|
||||
|
||||
if custom_pkgbuild:
|
||||
cmd.append('-p')
|
||||
cmd.append(custom_pkgbuild)
|
||||
|
||||
if optimize:
|
||||
if os.path.exists(CUSTOM_MAKEPKG_FILE):
|
||||
handler.watcher.print(f'Using custom makepkg.conf -> {CUSTOM_MAKEPKG_FILE}')
|
||||
cmd.append(f'--config={CUSTOM_MAKEPKG_FILE}')
|
||||
else:
|
||||
handler.watcher.print(f'Custom optimized makepkg.conf ({CUSTOM_MAKEPKG_FILE}) not found')
|
||||
|
||||
success, output = handler.handle_simple(SimpleProcess(cmd, cwd=project_dir, shell=True, custom_user=custom_user))
|
||||
|
||||
if missing_deps and 'Missing dependencies' in output:
|
||||
res['missing_deps'] = RE_DEPS_PATTERN.findall(output)
|
||||
|
||||
gpg_keys = RE_UNKNOWN_GPG_KEY.findall(output)
|
||||
|
||||
if gpg_keys:
|
||||
res['gpg_key'] = gpg_keys[0]
|
||||
|
||||
if 'One or more files did not pass the validity check' in output:
|
||||
res['validity_check'] = True
|
||||
|
||||
return res
|
||||
@@ -1,129 +0,0 @@
|
||||
import logging
|
||||
import os
|
||||
from typing import Optional, List, Dict
|
||||
|
||||
from bauh.api.abstract.model import PackageStatus
|
||||
from bauh.api.http import HttpClient
|
||||
from bauh.gems.arch.model import ArchPackage
|
||||
from bauh.commons.version_util import normalize_version
|
||||
from bauh.view.util.translation import I18n
|
||||
|
||||
URL_PKG_DOWNLOAD = 'https://aur.archlinux.org/{}'
|
||||
|
||||
|
||||
class AURDataMapper:
|
||||
|
||||
def __init__(self, http_client: HttpClient, i18n: I18n, logger: logging.Logger):
|
||||
self.http_client = http_client
|
||||
self.i18n = i18n
|
||||
self.logger = logger
|
||||
|
||||
def fill_last_modified(self, pkg: ArchPackage, api_data: dict):
|
||||
last_modified = api_data.get('LastModified')
|
||||
if last_modified is not None and isinstance(last_modified, int):
|
||||
pkg.last_modified = last_modified
|
||||
self.logger.info("'last_modified' field ({}) set to package '{}'".format(last_modified, pkg.name))
|
||||
else:
|
||||
self.logger.warning("Could not set the 'last_modified' field ({}) to package '{}'".format(last_modified, pkg.name))
|
||||
|
||||
def fill_api_data(self, pkg: ArchPackage, api_data: dict, fill_version: bool = True):
|
||||
pkg.id = api_data.get('ID')
|
||||
|
||||
if not pkg.name:
|
||||
pkg.name = api_data.get('Name')
|
||||
|
||||
if not pkg.description:
|
||||
pkg.description = api_data.get('Description')
|
||||
|
||||
pkg.package_base = api_data.get('PackageBase')
|
||||
pkg.popularity = api_data.get('Popularity')
|
||||
pkg.votes = api_data.get('NumVotes')
|
||||
pkg.maintainer = api_data.get('Maintainer')
|
||||
pkg.url_download = URL_PKG_DOWNLOAD.format(api_data['URLPath']) if api_data.get('URLPath') else None
|
||||
pkg.out_of_date = bool(api_data.get('OutOfDate'))
|
||||
|
||||
if api_data['FirstSubmitted'] and isinstance(api_data['FirstSubmitted'], int):
|
||||
pkg.first_submitted = api_data['FirstSubmitted']
|
||||
|
||||
if not pkg.installed:
|
||||
self.fill_last_modified(pkg=pkg, api_data=api_data)
|
||||
|
||||
version = api_data.get('Version')
|
||||
|
||||
if version:
|
||||
version = version.split(':')
|
||||
version = version[0] if len(version) == 1 else version[1]
|
||||
|
||||
if fill_version:
|
||||
pkg.version = version
|
||||
|
||||
pkg.latest_version = version
|
||||
|
||||
@staticmethod
|
||||
def check_version_update(version: str, latest_version: str) -> bool:
|
||||
if version and latest_version and version != latest_version:
|
||||
return normalize_version(latest_version) > normalize_version(version)
|
||||
|
||||
return False
|
||||
|
||||
def fill_package_build(self, pkg: ArchPackage):
|
||||
cached_pkgbuild = pkg.get_cached_pkgbuild_path()
|
||||
if pkg.installed and os.path.exists(cached_pkgbuild):
|
||||
with open(cached_pkgbuild) as f:
|
||||
pkg.pkgbuild = f.read()
|
||||
else:
|
||||
url = pkg.get_pkg_build_url()
|
||||
|
||||
if url:
|
||||
res = self.http_client.get(url)
|
||||
|
||||
if res and res.status_code == 200 and res.text:
|
||||
pkg.pkgbuild = res.text
|
||||
|
||||
def map_api_data(self, apidata: dict, pkgs_installed: Optional[dict], categories: Dict[str, List[str]]) -> ArchPackage:
|
||||
data = pkgs_installed.get(apidata.get('Name')) if pkgs_installed else None
|
||||
app = ArchPackage(name=apidata.get('Name'), installed=bool(data), repository='aur', i18n=self.i18n)
|
||||
app.status = PackageStatus.LOADING_DATA
|
||||
|
||||
if categories:
|
||||
app.categories = categories.get(app.name)
|
||||
|
||||
if data:
|
||||
app.version = data.get('version')
|
||||
app.description = data.get('description')
|
||||
|
||||
self.fill_api_data(app, apidata, fill_version=not data)
|
||||
|
||||
if app.orphan or app.out_of_date:
|
||||
if app.categories is None:
|
||||
app.categories = []
|
||||
|
||||
if app.orphan:
|
||||
app.categories.append('orphan')
|
||||
|
||||
if app.out_of_date:
|
||||
app.categories.append('out_of_date')
|
||||
|
||||
return app
|
||||
|
||||
def check_update(self, pkg: ArchPackage, last_modified: Optional[int]) -> bool:
|
||||
valid_last_modified = last_modified is not None and isinstance(last_modified, int)
|
||||
|
||||
if not valid_last_modified:
|
||||
self.logger.warning("'last_modified' timestamp informed for package '{}' is invalid: {}".format(pkg.name, valid_last_modified))
|
||||
|
||||
pkg_last_modified_ts = pkg.last_modified if pkg.last_modified is not None else pkg.install_date
|
||||
|
||||
if pkg.last_modified is None:
|
||||
self.logger.warning("AUR package '{}' has no 'last_modified' field set.".format(pkg.name))
|
||||
|
||||
if pkg.install_date is None:
|
||||
self.logger.warning("AUR package '{}' has no 'install_date' field set".format(pkg.name))
|
||||
self.logger.warning("Update checking for AUR package '{}' will only consider version strings".format(pkg.name))
|
||||
else:
|
||||
self.logger.warning("AUR package {} 'install_date' field will be used for update checking".format(pkg.name))
|
||||
|
||||
if pkg_last_modified_ts is not None and valid_last_modified and pkg_last_modified_ts < last_modified:
|
||||
return True
|
||||
else:
|
||||
return self.check_version_update(pkg.version, pkg.latest_version)
|
||||
@@ -1,33 +0,0 @@
|
||||
from typing import Iterable, Optional
|
||||
|
||||
from bauh.api.abstract.handler import ProcessWatcher
|
||||
from bauh.api.abstract.view import MessageType
|
||||
from bauh.commons.html import bold
|
||||
from bauh.view.util.translation import I18n
|
||||
|
||||
|
||||
def show_deps_not_installed(watcher: ProcessWatcher, pkgname: str, depnames: Iterable[str], i18n: I18n):
|
||||
deps = ', '.join((bold(d) for d in depnames))
|
||||
watcher.show_message(title=i18n['error'].capitalize(),
|
||||
body=i18n['arch.install.dependency.install.error'].format(deps, bold(pkgname)),
|
||||
type_=MessageType.ERROR)
|
||||
|
||||
|
||||
def show_dep_not_found(depname: str, i18n: I18n, watcher: ProcessWatcher, dependent: Optional[str] = None):
|
||||
|
||||
source = f" {bold('(' + dependent + ')')}" if dependent else ''
|
||||
|
||||
body = f"<p>{i18n['arch.install.dep_not_found.body.l1'].format(dep=bold(depname), source=source)}</p>" \
|
||||
f"<p><{i18n['arch.install.dep_not_found.body.l2']}</p>" \
|
||||
f"<p>{i18n['arch.install.dep_not_found.body.l3']}</p>"
|
||||
|
||||
watcher.show_message(title=i18n['arch.install.dep_not_found.title'].capitalize(),
|
||||
body=body,
|
||||
type_=MessageType.ERROR)
|
||||
|
||||
|
||||
def show_optdeps_not_installed(depnames: Iterable[str], watcher: ProcessWatcher, i18n: I18n):
|
||||
deps = ', '.join((bold(d) for d in depnames))
|
||||
watcher.show_message(title=i18n['error'].capitalize(),
|
||||
body=i18n['arch.install.optdep.error'].format(deps),
|
||||
type_=MessageType.ERROR)
|
||||
@@ -1,42 +0,0 @@
|
||||
import logging
|
||||
import os
|
||||
import time
|
||||
import traceback
|
||||
from datetime import datetime
|
||||
from logging import Logger
|
||||
from pathlib import Path
|
||||
|
||||
from bauh.api.paths import CACHE_DIR
|
||||
|
||||
SYNC_FILE = f'{CACHE_DIR}/arch/mirrors_sync'
|
||||
|
||||
|
||||
def should_sync(logger: logging.Logger):
|
||||
if os.path.exists(SYNC_FILE):
|
||||
with open(SYNC_FILE) as f:
|
||||
sync_file = f.read()
|
||||
|
||||
try:
|
||||
sync_time = datetime.fromtimestamp(int(sync_file))
|
||||
now = datetime.now()
|
||||
|
||||
if now > sync_time and now.day != sync_time.day:
|
||||
logger.info("Package databases synchronization out of date")
|
||||
else:
|
||||
msg = "Package databases already synchronized"
|
||||
logger.info(msg)
|
||||
return False
|
||||
except Exception:
|
||||
logger.warning("Could not convert the database synchronization time from '{}".format(SYNC_FILE))
|
||||
traceback.print_exc()
|
||||
return True
|
||||
|
||||
|
||||
def register_sync(logger: Logger):
|
||||
try:
|
||||
Path('/'.join(SYNC_FILE.split('/')[0:-1])).mkdir(parents=True, exist_ok=True)
|
||||
with open(SYNC_FILE, 'w+') as f:
|
||||
f.write(str(int(time.time())))
|
||||
except Exception:
|
||||
logger.error("Could not write to mirrors sync file '{}'".format(SYNC_FILE))
|
||||
traceback.print_exc()
|
||||
@@ -1,293 +0,0 @@
|
||||
from typing import List, Set, Optional, Iterable, Tuple
|
||||
|
||||
from bauh.api.abstract.model import SoftwarePackage, CustomSoftwareAction
|
||||
from bauh.commons import resource
|
||||
from bauh.gems.arch import ROOT_DIR, ARCH_CACHE_DIR
|
||||
from bauh.view.util.translation import I18n
|
||||
|
||||
|
||||
class ArchPackage(SoftwarePackage):
|
||||
|
||||
__action_allow_rebuild_check: Optional[CustomSoftwareAction] = None
|
||||
__action_enable_pkgbuild_edition: Optional[CustomSoftwareAction] = None
|
||||
__action_disable_pkgbuild_edition: Optional[CustomSoftwareAction] = None
|
||||
__action_reinstall: Optional[CustomSoftwareAction] = None
|
||||
__action_ignore_rebuild_check: Optional[CustomSoftwareAction] = None
|
||||
__cached_attrs: Optional[Tuple[str, ...]] = None
|
||||
__dynamic_categories: Optional[Tuple[str, ...]] = None
|
||||
|
||||
@classmethod
|
||||
def action_allow_rebuild_check(cls) -> CustomSoftwareAction:
|
||||
if not cls.__action_allow_rebuild_check:
|
||||
cls.__action_allow_rebuild_check = CustomSoftwareAction(i18n_label_key='arch.action.rebuild_check.allow',
|
||||
i18n_status_key='arch.action.rebuild_check.allow.status',
|
||||
i18n_confirm_key='arch.action.rebuild_check.allow.confirm',
|
||||
i18n_description_key='arch.action.rebuild_check.allow.desc',
|
||||
requires_root=False,
|
||||
manager_method='set_rebuild_check',
|
||||
icon_path=resource.get_path('img/check.svg', ROOT_DIR))
|
||||
|
||||
return cls.__action_allow_rebuild_check
|
||||
|
||||
@classmethod
|
||||
def action_enable_pkgbuild_edition(cls) -> CustomSoftwareAction:
|
||||
if not cls.__action_enable_pkgbuild_edition:
|
||||
cls.__action_enable_pkgbuild_edition = CustomSoftwareAction(i18n_label_key='arch.action.enable_pkgbuild_edition',
|
||||
i18n_status_key='arch.action.enable_pkgbuild_edition.status',
|
||||
i18n_confirm_key='arch.action.enable_pkgbuild_edition.confirm',
|
||||
i18n_description_key='arch.action.enable_pkgbuild_edition.desc',
|
||||
requires_root=False,
|
||||
manager_method='enable_pkgbuild_edition',
|
||||
icon_path=resource.get_path('img/mark_pkgbuild.svg', ROOT_DIR))
|
||||
|
||||
return cls.__action_enable_pkgbuild_edition
|
||||
|
||||
@classmethod
|
||||
def action_disable_pkgbuild_edition(cls) -> CustomSoftwareAction:
|
||||
if not cls.__action_disable_pkgbuild_edition:
|
||||
cls.__action_disable_pkgbuild_edition = CustomSoftwareAction(i18n_label_key='arch.action.disable_pkgbuild_edition',
|
||||
i18n_status_key='arch.action.disable_pkgbuild_edition',
|
||||
i18n_confirm_key='arch.action.disable_pkgbuild_edition.confirm',
|
||||
i18n_description_key='arch.action.disable_pkgbuild_edition.desc',
|
||||
requires_root=False,
|
||||
manager_method='disable_pkgbuild_edition',
|
||||
icon_path=resource.get_path('img/unmark_pkgbuild.svg', ROOT_DIR))
|
||||
|
||||
return cls.__action_disable_pkgbuild_edition
|
||||
|
||||
@classmethod
|
||||
def action_reinstall(cls) -> CustomSoftwareAction:
|
||||
if not cls.__action_reinstall:
|
||||
cls.__action_reinstall = CustomSoftwareAction(i18n_label_key='arch.action.reinstall',
|
||||
i18n_status_key='arch.action.reinstall.status',
|
||||
i18n_confirm_key='arch.action.reinstall.confirm',
|
||||
i18n_description_key='arch.action.reinstall.desc',
|
||||
requires_root=True,
|
||||
manager_method='reinstall',
|
||||
icon_path=resource.get_path('img/build.svg', ROOT_DIR))
|
||||
|
||||
return cls.__action_reinstall
|
||||
|
||||
@classmethod
|
||||
def action_ignore_rebuild_check(cls) -> CustomSoftwareAction:
|
||||
if not cls.__action_ignore_rebuild_check:
|
||||
cls.__action_ignore_rebuild_check = CustomSoftwareAction(i18n_label_key='arch.action.rebuild_check.ignore',
|
||||
i18n_status_key='arch.action.rebuild_check.ignore.status',
|
||||
i18n_confirm_key='arch.action.rebuild_check.ignore.confirm',
|
||||
i18n_description_key='arch.action.rebuild_check.ignore.desc',
|
||||
requires_root=False,
|
||||
manager_method='set_rebuild_check',
|
||||
icon_path=resource.get_path('img/check_disabled.svg', ROOT_DIR))
|
||||
|
||||
return cls.__action_ignore_rebuild_check
|
||||
|
||||
@classmethod
|
||||
def cached_attrs(cls) -> Tuple[str, ...]:
|
||||
if cls.__cached_attrs is None:
|
||||
cls.__cached_attrs = ('command', 'icon_path', 'repository', 'maintainer', 'desktop_entry', 'categories',
|
||||
'last_modified', 'commit')
|
||||
|
||||
return cls.__cached_attrs
|
||||
|
||||
@classmethod
|
||||
def dynamic_categories(cls) -> Tuple[str, ...]:
|
||||
if cls.__dynamic_categories is None:
|
||||
cls.__dynamic_categories = ('orphan', 'out_of_date')
|
||||
|
||||
return cls.__dynamic_categories
|
||||
|
||||
def __init__(self, name: str = None, version: str = None, latest_version: str = None, description: str = None,
|
||||
package_base: str = None, votes: int = None, popularity: float = None,
|
||||
first_submitted: Optional[int] = None, last_modified: Optional[int] = None,
|
||||
maintainer: str = None, url_download: str = None, pkgbuild: str = None, repository: str = None,
|
||||
desktop_entry: str = None, installed: bool = False, srcinfo: dict = None, dependencies: Set[str] = None,
|
||||
categories: List[str] = None, i18n: I18n = None, update_ignored: bool = False, arch: str = None,
|
||||
pkgbuild_editable: bool = None, install_date: Optional[int] = None, commit: Optional[str] = None,
|
||||
require_rebuild: bool = False, allow_rebuild: Optional[bool] = None, aur_update: bool = False,
|
||||
out_of_date: Optional[bool] = None):
|
||||
|
||||
super(ArchPackage, self).__init__(name=name, version=version, latest_version=latest_version, description=description,
|
||||
installed=installed, categories=categories)
|
||||
self.package_base = package_base
|
||||
self.votes = votes
|
||||
self.popularity = popularity
|
||||
self.maintainer = maintainer if maintainer else (repository if repository != 'aur' else None)
|
||||
self.url_download = url_download
|
||||
self.first_submitted = first_submitted
|
||||
self.last_modified = last_modified
|
||||
self.pkgbuild = pkgbuild
|
||||
self.repository = repository
|
||||
self.command = None
|
||||
self.icon_path = None
|
||||
self.desktop_entry = desktop_entry
|
||||
self.src_info = srcinfo
|
||||
self.dependencies = dependencies
|
||||
self.arch = arch
|
||||
self.i18n = i18n
|
||||
self.update_ignored = update_ignored
|
||||
self.view_name = name # name displayed on the view
|
||||
self.pkgbuild_editable = pkgbuild_editable # if the PKGBUILD can be edited by the user (only for AUR)
|
||||
self.install_date = install_date
|
||||
self.commit = commit # only for AUR for downgrading purposes
|
||||
self.require_rebuild = require_rebuild
|
||||
self.allow_rebuild = allow_rebuild
|
||||
self.aur_update = aur_update
|
||||
self.out_of_date = out_of_date
|
||||
|
||||
@staticmethod
|
||||
def disk_cache_path(pkgname: str):
|
||||
return f'{ARCH_CACHE_DIR}/installed/{pkgname}'
|
||||
|
||||
def get_pkg_build_url(self):
|
||||
if self.package_base:
|
||||
return 'https://aur.archlinux.org/cgit/aur.git/plain/PKGBUILD?h=' + self.package_base
|
||||
|
||||
def has_history(self):
|
||||
return self.can_be_downgraded()
|
||||
|
||||
def has_info(self):
|
||||
return True
|
||||
|
||||
def can_be_installed(self) -> bool:
|
||||
if super(ArchPackage, self).can_be_installed():
|
||||
return bool(self.url_download) if self.repository == 'aur' else True
|
||||
|
||||
def can_be_downgraded(self):
|
||||
return self.installed and self.repository == 'aur'
|
||||
|
||||
def get_type(self):
|
||||
return 'aur' if self.repository == 'aur' else 'arch_repo'
|
||||
|
||||
def get_default_icon_path(self) -> str:
|
||||
return self.get_type_icon_path()
|
||||
|
||||
def get_disk_icon_path(self) -> str:
|
||||
return self.icon_path
|
||||
|
||||
def get_type_icon_path(self):
|
||||
return resource.get_path('img/{}.svg'.format('arch' if self.get_type() == 'aur' else 'repo'), ROOT_DIR)
|
||||
|
||||
def is_application(self):
|
||||
return self.can_be_run()
|
||||
|
||||
def get_base_name(self) -> str:
|
||||
return self.package_base if self.package_base else self.name
|
||||
|
||||
def supports_disk_cache(self):
|
||||
return True
|
||||
|
||||
def get_disk_cache_path(self) -> str:
|
||||
if self.name:
|
||||
return self.disk_cache_path(self.name)
|
||||
|
||||
def get_data_to_cache(self) -> dict:
|
||||
cache = {}
|
||||
|
||||
# required attrs to cache
|
||||
for a in self.cached_attrs():
|
||||
val = getattr(self, a)
|
||||
|
||||
if val:
|
||||
if a == 'categories' and isinstance(val, list):
|
||||
for cat in self.dynamic_categories():
|
||||
if cat in val:
|
||||
val.remove(cat)
|
||||
|
||||
cache[a] = val
|
||||
|
||||
return cache
|
||||
|
||||
def fill_cached_data(self, data: dict):
|
||||
if data:
|
||||
for a in self.cached_attrs():
|
||||
val = data.get(a)
|
||||
if val:
|
||||
setattr(self, a, val)
|
||||
|
||||
if a == 'icon_path':
|
||||
self.icon_url = val
|
||||
|
||||
def can_be_run(self) -> bool:
|
||||
# only returns if there is a desktop entry set for the application to avoid running command-line applications
|
||||
return bool(self.desktop_entry) and bool(self.command)
|
||||
|
||||
def get_publisher(self):
|
||||
return self.maintainer
|
||||
|
||||
def set_icon(self, paths: List[str]):
|
||||
self.icon_path = paths[0]
|
||||
|
||||
if len(paths) > 1:
|
||||
for path in paths:
|
||||
if '/' in path:
|
||||
self.icon_path = path
|
||||
break
|
||||
|
||||
self.icon_url = self.icon_path
|
||||
|
||||
def has_screenshots(self) -> bool:
|
||||
return False
|
||||
|
||||
def get_name_tooltip(self) -> str:
|
||||
return '{} ( {}: {} )'.format(self.name, self.i18n['repository'], self.repository)
|
||||
|
||||
def supports_backup(self) -> bool:
|
||||
return True
|
||||
|
||||
def is_update_ignored(self) -> bool:
|
||||
return self.update_ignored
|
||||
|
||||
def supports_ignored_updates(self) -> bool:
|
||||
return self.installed
|
||||
|
||||
def __str__(self):
|
||||
return self.__repr__()
|
||||
|
||||
def __repr__(self):
|
||||
return '{} (name={}, command={}, icon_path={})'.format(self.__class__.__name__, self.name, self.command, self.icon_path)
|
||||
|
||||
def __eq__(self, other):
|
||||
if isinstance(other, ArchPackage):
|
||||
if self.view_name is not None and other.view_name is not None:
|
||||
return self.view_name == other.view_name and self.repository == other.repository
|
||||
|
||||
return self.name == other.name and self.repository == other.repository
|
||||
|
||||
def get_cached_pkgbuild_path(self) -> str:
|
||||
return '{}/PKGBUILD'.format(self.get_disk_cache_path())
|
||||
|
||||
def get_custom_actions(self) -> Optional[Iterable[CustomSoftwareAction]]:
|
||||
if self.installed and self.repository == 'aur':
|
||||
actions = [self.action_reinstall()]
|
||||
|
||||
if self.pkgbuild_editable is not None:
|
||||
actions.append(self.action_disable_pkgbuild_edition() if self.pkgbuild_editable else self.action_enable_pkgbuild_edition())
|
||||
|
||||
if self.allow_rebuild is not None:
|
||||
actions.append(self.action_ignore_rebuild_check() if self.allow_rebuild else self.action_allow_rebuild_check())
|
||||
|
||||
return actions
|
||||
|
||||
def get_update_tip(self) -> Optional[str]:
|
||||
if self.repository == 'aur' and self.allow_rebuild and self.require_rebuild:
|
||||
return self.i18n['arch.package.requires_rebuild'] + ' (rebuild)'
|
||||
|
||||
def update_state(self):
|
||||
if self.repository == 'aur':
|
||||
if self.allow_rebuild and self.require_rebuild:
|
||||
self.update = True
|
||||
else:
|
||||
self.update = self.aur_update
|
||||
|
||||
def __hash__(self):
|
||||
if self.view_name is not None:
|
||||
return hash((self.view_name, self.repository))
|
||||
else:
|
||||
return hash((self.name, self.repository))
|
||||
|
||||
@property
|
||||
def orphan(self) -> bool:
|
||||
return self.maintainer is None
|
||||
|
||||
def is_trustable(self) -> bool:
|
||||
return self.repository and self.repository != "aur"
|
||||
@@ -1,130 +0,0 @@
|
||||
import logging
|
||||
import time
|
||||
from threading import Thread
|
||||
from typing import Optional, Collection
|
||||
|
||||
from bauh.api.abstract.handler import ProcessWatcher
|
||||
from bauh.commons.html import bold
|
||||
from bauh.view.util.translation import I18n
|
||||
|
||||
|
||||
class TransactionStatusHandler(Thread):
|
||||
|
||||
def __init__(self, watcher: ProcessWatcher, i18n: I18n, names: Optional[Collection[str]], logger: logging.Logger,
|
||||
percentage: bool = True, downloading: int = 0, pkgs_to_remove: int = 0):
|
||||
super(TransactionStatusHandler, self).__init__(daemon=True)
|
||||
self.watcher = watcher
|
||||
self.i18n = i18n
|
||||
self.names = names
|
||||
self.pkgs_to_sync = len(names) if names else 0
|
||||
self.pkgs_to_remove = pkgs_to_remove
|
||||
self.downloading = downloading
|
||||
self.upgrading = 0
|
||||
self.installing = 0
|
||||
self.removing = 0
|
||||
self.outputs = []
|
||||
self.work = True
|
||||
self.logger = logger
|
||||
self.percentage = percentage
|
||||
self.accepted = {'checking keyring': 'keyring',
|
||||
'checking package integrity': 'integrity',
|
||||
'loading package files': 'loading_files',
|
||||
'checking for file conflicts': 'conflicts',
|
||||
'checking available disk space': 'disk_space',
|
||||
':: running pre-transaction hooks': 'pre_hooks',
|
||||
':: retrieving packages': 'retrieve_pkgs'}
|
||||
|
||||
def gen_percentage(self) -> str:
|
||||
if self.percentage:
|
||||
performed = self.downloading + self.upgrading + self.installing
|
||||
return f'({(performed / (2 * self.pkgs_to_sync)) * 100:.2f}%) '
|
||||
else:
|
||||
return ''
|
||||
|
||||
def get_performed(self) -> int:
|
||||
return self.upgrading + self.installing
|
||||
|
||||
def _handle(self, output: str) -> bool:
|
||||
if output:
|
||||
output_split = output.split(' ')
|
||||
|
||||
if output_split[0].lower() == 'removing' and (not self.names or output_split[1].split('.')[0] in self.names):
|
||||
if self.pkgs_to_remove > 0:
|
||||
self.removing += 1
|
||||
|
||||
self.watcher.change_substatus(f"[{self.removing}/{self.pkgs_to_remove}] "
|
||||
f"{self.i18n['uninstalling'].capitalize()} {output.split(' ')[1].strip()}")
|
||||
else:
|
||||
self.watcher.change_substatus(f"{self.i18n['uninstalling'].capitalize()} {output_split[1].strip()}")
|
||||
|
||||
elif len(output_split) >= 2 and output_split[1].lower().startswith('downloading') and (not self.names or (n for n in self.names if output_split[0].startswith(n))):
|
||||
if self.downloading < self.pkgs_to_sync:
|
||||
perc = self.gen_percentage()
|
||||
self.downloading += 1
|
||||
|
||||
self.watcher.change_substatus(f"{perc}[{self.downloading}/{self.pkgs_to_sync}] {bold('[pacman]')} "
|
||||
f"{self.i18n['downloading'].capitalize()} {output_split[0].strip()}")
|
||||
|
||||
elif output_split[0].lower() == 'upgrading' and (not self.names or output_split[1].split('.')[0] in self.names):
|
||||
if self.get_performed() < self.pkgs_to_sync:
|
||||
perc = self.gen_percentage()
|
||||
self.upgrading += 1
|
||||
|
||||
performed = self.upgrading + self.installing
|
||||
|
||||
if performed <= self.pkgs_to_sync:
|
||||
self.watcher.change_substatus(f"{perc}[{performed}/{self.pkgs_to_sync}] "
|
||||
f"{self.i18n['manage_window.status.upgrading'].capitalize()} {output_split[1].strip()}")
|
||||
|
||||
elif output_split[0].lower() == 'installing' and (not self.names or output_split[1].split('.')[0] in self.names):
|
||||
if self.get_performed() < self.pkgs_to_sync:
|
||||
perc = self.gen_percentage()
|
||||
self.installing += 1
|
||||
|
||||
performed = self.upgrading + self.installing
|
||||
|
||||
if performed <= self.pkgs_to_sync:
|
||||
self.watcher.change_substatus(f"{perc}[{performed}/{self.pkgs_to_sync}] "
|
||||
f"{self.i18n['manage_window.status.installing'].capitalize()} {output_split[1].strip()}")
|
||||
else:
|
||||
substatus_found = False
|
||||
lower_output = output.lower().strip()
|
||||
for msg, key in self.accepted.items():
|
||||
if lower_output.startswith(msg):
|
||||
self.watcher.change_substatus(self.i18n[f'arch.substatus.{key}'].capitalize())
|
||||
substatus_found = True
|
||||
break
|
||||
|
||||
if not substatus_found:
|
||||
if self.pkgs_to_remove > 0:
|
||||
if self.pkgs_to_remove == self.removing:
|
||||
self.watcher.change_substatus('')
|
||||
return False
|
||||
else:
|
||||
performed = self.get_performed()
|
||||
|
||||
if performed == self.pkgs_to_sync:
|
||||
self.watcher.change_substatus(self.i18n['finishing'].capitalize())
|
||||
return False
|
||||
else:
|
||||
self.watcher.change_substatus('')
|
||||
|
||||
return True
|
||||
|
||||
def handle(self, output: str):
|
||||
self.outputs.insert(0, output)
|
||||
|
||||
def stop_working(self):
|
||||
self.work = False
|
||||
|
||||
def run(self):
|
||||
self.logger.info("Starting")
|
||||
while self.work:
|
||||
if self.outputs:
|
||||
output = self.outputs.pop()
|
||||
if not self._handle(output):
|
||||
break
|
||||
else:
|
||||
time.sleep(0.005)
|
||||
|
||||
self.logger.info("Finished")
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,26 +0,0 @@
|
||||
import re
|
||||
from typing import Set
|
||||
|
||||
RE_PKGBUILD_OPTDEPS = re.compile(r"optdepends = (.+)")
|
||||
RE_PKGBUILD_OPTDEPS_x86_64 = re.compile(r"optdepends_x86_64 = (.+)")
|
||||
RE_PKGBUILD_OPTDEPS_i686 = re.compile(r"optdepends_i686 = (.+)")
|
||||
|
||||
|
||||
def read_optdeps_as_dict(srcinfo: str, x86_64: bool) -> dict:
|
||||
res = {}
|
||||
for optdep in read_optdeps(srcinfo, x86_64):
|
||||
split_dep = optdep.split(':')
|
||||
res[split_dep[0].strip()] = split_dep[1].strip() if len(split_dep) > 1 else None
|
||||
|
||||
return res
|
||||
|
||||
|
||||
def read_optdeps(srcinfo: str, x86_64: bool) -> Set[str]:
|
||||
optdeps = set(RE_PKGBUILD_OPTDEPS.findall(srcinfo))
|
||||
|
||||
if x86_64:
|
||||
optdeps.update(set(RE_PKGBUILD_OPTDEPS_x86_64.findall(srcinfo)))
|
||||
else:
|
||||
optdeps.update(set(RE_PKGBUILD_OPTDEPS_i686.findall(srcinfo)))
|
||||
|
||||
return optdeps
|
||||
@@ -1,51 +0,0 @@
|
||||
import multiprocessing
|
||||
import os
|
||||
import traceback
|
||||
from pwd import getpwnam
|
||||
from typing import Callable, Optional, TypeVar
|
||||
|
||||
R = TypeVar('R')
|
||||
|
||||
|
||||
class CallAsUser:
|
||||
|
||||
def __init__(self, target: Callable[[], R], user: str):
|
||||
self._target = target
|
||||
self._user = user
|
||||
|
||||
def __call__(self, *args, **kwargs) -> R:
|
||||
try:
|
||||
os.setuid(getpwnam(self._user).pw_uid)
|
||||
return self._target()
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
|
||||
|
||||
class WriteToFile:
|
||||
|
||||
def __init__(self, file_path: str, content: str):
|
||||
self._file_path = file_path
|
||||
self._content = content
|
||||
|
||||
def __call__(self, *args, **kwargs) -> bool:
|
||||
try:
|
||||
with open(self._file_path, 'w+') as f:
|
||||
f.write(self._content)
|
||||
|
||||
return True
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
return False
|
||||
|
||||
|
||||
def exec_as_user(target: Callable[[], R], user: Optional[str] = None) -> R:
|
||||
if user:
|
||||
with multiprocessing.Pool(1) as pool:
|
||||
return pool.apply(CallAsUser(target, user))
|
||||
else:
|
||||
return target()
|
||||
|
||||
|
||||
def write_as_user(content: str, file_path: str, user: Optional[str] = None) -> bool:
|
||||
return exec_as_user(target=WriteToFile(file_path=file_path, content=content),
|
||||
user=user)
|
||||
@@ -1,67 +0,0 @@
|
||||
import os
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
from typing import Set
|
||||
|
||||
from bauh.commons import system
|
||||
from bauh.gems.arch import IGNORED_REBUILD_CHECK_FILE
|
||||
|
||||
|
||||
def is_installed() -> bool:
|
||||
return bool(shutil.which('checkrebuild'))
|
||||
|
||||
|
||||
def list_required_rebuild() -> Set[str]:
|
||||
code, output = system.execute(cmd='checkrebuild', shell=True, stdin=False)
|
||||
|
||||
required = set()
|
||||
if code == 0 and output:
|
||||
for line in output.split('\n'):
|
||||
line_strip = line.strip()
|
||||
|
||||
if line_strip:
|
||||
line_split = line_strip.split('\t')
|
||||
|
||||
if len(line_split) > 1:
|
||||
required.add(line_split[1])
|
||||
|
||||
return required
|
||||
|
||||
|
||||
def list_ignored() -> Set[str]:
|
||||
if os.path.isfile(IGNORED_REBUILD_CHECK_FILE):
|
||||
with open(IGNORED_REBUILD_CHECK_FILE) as f:
|
||||
ignored_str = f.read()
|
||||
|
||||
return {p.strip() for p in ignored_str.split('\n') if p}
|
||||
else:
|
||||
return set()
|
||||
|
||||
|
||||
def add_as_ignored(pkgname: str):
|
||||
ignored = list_ignored()
|
||||
ignored.add(pkgname)
|
||||
|
||||
Path(os.path.dirname(IGNORED_REBUILD_CHECK_FILE)).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
with open(IGNORED_REBUILD_CHECK_FILE, 'w+') as f:
|
||||
for p in ignored:
|
||||
f.write('{}\n'.format(p))
|
||||
|
||||
|
||||
def remove_from_ignored(pkgname: str):
|
||||
ignored = list_ignored()
|
||||
|
||||
if ignored is None or pkgname not in ignored:
|
||||
return
|
||||
|
||||
ignored.remove(pkgname)
|
||||
|
||||
Path(os.path.dirname(IGNORED_REBUILD_CHECK_FILE)).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
if ignored:
|
||||
with open(IGNORED_REBUILD_CHECK_FILE, 'w+') as f:
|
||||
for p in ignored:
|
||||
f.write('{}\n'.format(p))
|
||||
else:
|
||||
os.remove(IGNORED_REBUILD_CHECK_FILE)
|
||||
@@ -1,52 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<svg
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/"
|
||||
xmlns:cc="http://creativecommons.org/ns#"
|
||||
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:svg="http://www.w3.org/2000/svg"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
enable-background="new 0 0 515.91 728.5"
|
||||
height="512"
|
||||
id="Layer_1"
|
||||
version="1.1"
|
||||
viewBox="0 0 512.00003 512"
|
||||
width="512"
|
||||
xml:space="preserve"
|
||||
sodipodi:docname="arch.svg"
|
||||
inkscape:version="0.92.5 (2060ec1f9f, 2020-04-08)"><metadata
|
||||
id="metadata4874"><rdf:RDF><cc:Work
|
||||
rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
|
||||
rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><sodipodi:namedview
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#666666"
|
||||
borderopacity="1"
|
||||
objecttolerance="10"
|
||||
gridtolerance="10"
|
||||
guidetolerance="10"
|
||||
inkscape:pageopacity="0"
|
||||
inkscape:pageshadow="2"
|
||||
inkscape:window-width="1366"
|
||||
inkscape:window-height="731"
|
||||
id="namedview4872"
|
||||
showgrid="false"
|
||||
inkscape:zoom="0.4609375"
|
||||
inkscape:cx="256"
|
||||
inkscape:cy="256"
|
||||
inkscape:window-x="0"
|
||||
inkscape:window-y="0"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:current-layer="Layer_1" /><defs
|
||||
id="defs7" /><g
|
||||
id="g3824"
|
||||
transform="matrix(0.88983051,0,0,0.88135594,160.00335,152.31045)"><path
|
||||
d="m -733.62329,72.267944 c 0,203.804876 -165.21649,369.021366 -369.02141,369.021366 -203.8048,0 -369.0213,-165.21649 -369.0213,-369.021366 0,-203.804874 165.2165,-369.021364 369.0213,-369.021364 203.80492,0 369.02141,165.21649 369.02141,369.021364 z"
|
||||
id="path4878"
|
||||
style="fill:#1793d1;fill-opacity:1;fill-rule:nonzero;stroke:none"
|
||||
transform="matrix(0.69372682,0,0,0.69372682,872.81612,67.513546)"
|
||||
inkscape:connector-curvature="0" /><path
|
||||
d="M 107.84949,-98.602257 C 92.493787,-60.954304 83.231987,-36.328024 66.135387,0.20085614 76.617787,11.312106 89.484387,24.251686 110.3795,38.865776 87.915087,29.621786 72.591587,20.341076 61.140187,10.710446 39.259887,56.367046 4.9797874,121.40283 -64.585822,246.39777 c 54.6762094,-31.56545 97.060109,-51.0259 136.559909,-58.45149 -1.696,-7.29506 -2.6605,-15.1861 -2.595,-23.41953 l 0.065,-1.7516 c 0.8677,-35.02952 19.09,-61.96722 40.676113,-60.13821 21.5861,1.82902 38.3647,31.72582 37.4971,66.75537 -0.1631,6.59145 -0.9065,12.93234 -2.2057,18.81346 39.0709,7.64297 81.0017,27.0536 134.93811,58.192 C 269.7144,226.81765 260.2216,209.1676 251.1563,192.3577 236.8771,181.29028 221.983,166.88599 191.602,151.29245 c 20.8822,5.42606 35.8334,11.68629 47.4876,18.68371 C 146.9204,-1.6272139 139.4566,-24.429744 107.84949,-98.602257 Z"
|
||||
id="path2518"
|
||||
style="fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:none"
|
||||
inkscape:connector-curvature="0" /></g></svg>
|
||||
|
Before Width: | Height: | Size: 3.0 KiB |
@@ -1,119 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<svg
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/"
|
||||
xmlns:cc="http://creativecommons.org/ns#"
|
||||
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:svg="http://www.w3.org/2000/svg"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
version="1.1"
|
||||
id="Capa_1"
|
||||
x="0px"
|
||||
y="0px"
|
||||
viewBox="0 0 512 512"
|
||||
xml:space="preserve"
|
||||
sodipodi:docname="build.svg"
|
||||
width="512"
|
||||
height="512"
|
||||
inkscape:version="1.0.1 (3bc2e813f5, 2020-09-07)"><metadata
|
||||
id="metadata947"><rdf:RDF><cc:Work
|
||||
rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
|
||||
rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
|
||||
id="defs945">
|
||||
|
||||
|
||||
|
||||
</defs><sodipodi:namedview
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#666666"
|
||||
borderopacity="1"
|
||||
objecttolerance="10"
|
||||
gridtolerance="10"
|
||||
guidetolerance="10"
|
||||
inkscape:pageopacity="0"
|
||||
inkscape:pageshadow="2"
|
||||
inkscape:window-width="1366"
|
||||
inkscape:window-height="739"
|
||||
id="namedview943"
|
||||
showgrid="false"
|
||||
inkscape:zoom="1.2142857"
|
||||
inkscape:cx="224"
|
||||
inkscape:cy="224"
|
||||
inkscape:window-x="0"
|
||||
inkscape:window-y="0"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:current-layer="Capa_1" />
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
<g
|
||||
id="g1754"><g
|
||||
id="g904"
|
||||
transform="matrix(1.1254561,0,0,1.1254561,3.8978336,3.8978336)"
|
||||
style="fill:#59a869;fill-opacity:1">
|
||||
<g
|
||||
id="g902"
|
||||
style="fill:#59a869;fill-opacity:1"
|
||||
transform="matrix(1.4025677,0,0,1.4025677,-90.175165,11.541824)">
|
||||
<path
|
||||
d="m 256.272,0 h -64.784 c -4.48,0 -8.752,1.872 -11.712,5.216 C 173.92,11.808 165.472,16 156.032,16 146.592,16 138.128,11.808 132.288,5.216 129.312,1.872 125.04,0 120.56,0 H 72.272 c -4.416,0 -8,3.584 -8,8 v 64 c 0,4.416 3.584,8 8,8 h 48.288 c 4.48,0 8.752,-1.872 11.712,-5.216 C 138.128,68.192 146.576,64 156.032,64 c 32,0 36.256,37.744 36.256,48 l -0.272,64 h 64 v -64 c 0,-28.16 16.56,-48 48.256,-48 32,0 56.976,19.904 70.976,42.72 l 8.48,-4.4 c 0,-0.032 0,-0.032 0,-0.032 C 363.936,44.432 297.136,0 256.272,0 Z m -144,32 h -32 V 16 h 32 z"
|
||||
id="path900"
|
||||
style="fill:#59a869;fill-opacity:1" />
|
||||
</g>
|
||||
</g><g
|
||||
id="g1709"><g
|
||||
id="g1712"><path
|
||||
d="m 309.83377,357.64138 c 5.05762,-43.91375 1.06571,-60.90544 -18.08097,-97.49327 h -72.25159 c -19.14669,36.58783 -23.13859,53.57952 -18.06291,97.49327 9.12177,78.94169 -0.70444,82.78571 -0.90315,98.31499 -0.19869,15.5293 11.27126,27.0335 25.17969,27.0335 h 59.84239 c 13.90845,0 25.36031,-11.5042 25.17969,-27.0335 -0.19869,-15.52928 -10.02491,-19.3733 -0.90315,-98.31499 z"
|
||||
id="path906"
|
||||
style="fill:#59a869;fill-opacity:1;stroke-width:0.99132" /></g></g><g
|
||||
id="g912">
|
||||
</g><g
|
||||
id="g914">
|
||||
</g><g
|
||||
id="g916">
|
||||
</g><g
|
||||
id="g918">
|
||||
</g><g
|
||||
id="g920">
|
||||
</g><g
|
||||
id="g922">
|
||||
</g><g
|
||||
id="g924">
|
||||
</g><g
|
||||
id="g926">
|
||||
</g><g
|
||||
id="g928">
|
||||
</g><g
|
||||
id="g930">
|
||||
</g><g
|
||||
id="g932">
|
||||
</g><g
|
||||
id="g934">
|
||||
</g><g
|
||||
id="g936">
|
||||
</g><g
|
||||
id="g938">
|
||||
</g><g
|
||||
id="g940">
|
||||
</g><rect
|
||||
style="fill:#59a869;fill-opacity:1;stroke:none;stroke-width:284.117;stroke-miterlimit:4;stroke-dasharray:none"
|
||||
id="rect1724"
|
||||
width="90.90567"
|
||||
height="36.153423"
|
||||
x="20.398468"
|
||||
y="37.148106" /></g></svg>
|
||||
|
Before Width: | Height: | Size: 3.4 KiB |
@@ -1,63 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<svg
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/"
|
||||
xmlns:cc="http://creativecommons.org/ns#"
|
||||
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:svg="http://www.w3.org/2000/svg"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
version="1.1"
|
||||
viewBox="0 0 512.00001 512"
|
||||
enable-background="new 0 0 26 26"
|
||||
id="svg817"
|
||||
sodipodi:docname="check.svg"
|
||||
width="512"
|
||||
height="512"
|
||||
inkscape:version="1.0.1 (3bc2e813f5, 2020-09-07)">
|
||||
<metadata
|
||||
id="metadata823">
|
||||
<rdf:RDF>
|
||||
<cc:Work
|
||||
rdf:about="">
|
||||
<dc:format>image/svg+xml</dc:format>
|
||||
<dc:type
|
||||
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
|
||||
<dc:title />
|
||||
</cc:Work>
|
||||
</rdf:RDF>
|
||||
</metadata>
|
||||
<defs
|
||||
id="defs821" />
|
||||
<sodipodi:namedview
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#666666"
|
||||
borderopacity="1"
|
||||
objecttolerance="10"
|
||||
gridtolerance="10"
|
||||
guidetolerance="10"
|
||||
inkscape:pageopacity="0"
|
||||
inkscape:pageshadow="2"
|
||||
inkscape:window-width="1366"
|
||||
inkscape:window-height="739"
|
||||
id="namedview819"
|
||||
showgrid="false"
|
||||
showborder="true"
|
||||
fit-margin-top="0"
|
||||
fit-margin-left="0"
|
||||
fit-margin-right="0"
|
||||
fit-margin-bottom="0"
|
||||
inkscape:zoom="0.84308888"
|
||||
inkscape:cx="364.16486"
|
||||
inkscape:cy="281.60119"
|
||||
inkscape:window-x="0"
|
||||
inkscape:window-y="0"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:current-layer="svg817"
|
||||
inkscape:document-rotation="0" />
|
||||
<path
|
||||
d="m 7.1896424,281.46877 c -3.9182273,-5.09374 -5.8774013,-12.73441 -5.8774013,-17.82813 0,-5.09374 1.959072,-12.73441 5.8776223,-17.82815 l 27.4278676,-35.6563 c 7.836472,-10.18747 19.591293,-10.18747 27.427884,0 l 1.959055,2.54694 107.75243,150.2657 c 3.91834,5.09374 9.79575,5.09374 13.71398,0 L 447.99541,8.952986 h 1.95907 v 0 c 7.8367,-10.187467 19.59149,-10.187467 27.42797,0 l 27.42788,35.656297 c 7.83657,10.187468 7.83657,25.468796 0,35.65628 v 0 L 191.34838,503.04705 c -3.91834,5.09364 -7.83648,7.64056 -13.71388,7.64056 -5.87762,0 -9.79575,-2.54692 -13.71399,-7.64056 L 11.107887,289.10934 Z"
|
||||
id="path815"
|
||||
inkscape:connector-curvature="0"
|
||||
style="fill:#499c54;fill-opacity:1;stroke-width:22.3376" />
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 2.4 KiB |
@@ -1,70 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<svg
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/"
|
||||
xmlns:cc="http://creativecommons.org/ns#"
|
||||
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:svg="http://www.w3.org/2000/svg"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
version="1.1"
|
||||
viewBox="0 0 512.00001 512"
|
||||
enable-background="new 0 0 26 26"
|
||||
id="svg817"
|
||||
sodipodi:docname="check_disabled.svg"
|
||||
width="512"
|
||||
height="512"
|
||||
inkscape:version="1.0.1 (3bc2e813f5, 2020-09-07)">
|
||||
<metadata
|
||||
id="metadata823">
|
||||
<rdf:RDF>
|
||||
<cc:Work
|
||||
rdf:about="">
|
||||
<dc:format>image/svg+xml</dc:format>
|
||||
<dc:type
|
||||
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
|
||||
<dc:title></dc:title>
|
||||
</cc:Work>
|
||||
</rdf:RDF>
|
||||
</metadata>
|
||||
<defs
|
||||
id="defs821" />
|
||||
<sodipodi:namedview
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#666666"
|
||||
borderopacity="1"
|
||||
objecttolerance="10"
|
||||
gridtolerance="10"
|
||||
guidetolerance="10"
|
||||
inkscape:pageopacity="0"
|
||||
inkscape:pageshadow="2"
|
||||
inkscape:window-width="1366"
|
||||
inkscape:window-height="739"
|
||||
id="namedview819"
|
||||
showgrid="false"
|
||||
showborder="true"
|
||||
fit-margin-top="0"
|
||||
fit-margin-left="0"
|
||||
fit-margin-right="0"
|
||||
fit-margin-bottom="0"
|
||||
inkscape:zoom="0.84308888"
|
||||
inkscape:cx="364.16486"
|
||||
inkscape:cy="281.60119"
|
||||
inkscape:window-x="0"
|
||||
inkscape:window-y="0"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:current-layer="svg817"
|
||||
inkscape:document-rotation="0" />
|
||||
<g
|
||||
id="g1547">
|
||||
<path
|
||||
d="m 7.1896424,281.46877 c -3.9182273,-5.09374 -5.8774013,-12.73441 -5.8774013,-17.82813 0,-5.09374 1.959072,-12.73441 5.8776223,-17.82815 l 27.4278676,-35.6563 c 7.836472,-10.18747 19.591293,-10.18747 27.427884,0 l 1.959055,2.54694 107.75243,150.2657 c 3.91834,5.09374 9.79575,5.09374 13.71398,0 L 447.99541,8.952986 h 1.95907 v 0 c 7.8367,-10.187467 19.59149,-10.187467 27.42797,0 l 27.42788,35.656297 c 7.83657,10.187468 7.83657,25.468796 0,35.65628 v 0 L 191.34838,503.04705 c -3.91834,5.09364 -7.83648,7.64056 -13.71388,7.64056 -5.87762,0 -9.79575,-2.54692 -13.71399,-7.64056 L 11.107887,289.10934 Z"
|
||||
id="path815"
|
||||
inkscape:connector-curvature="0"
|
||||
style="fill:#499c54;fill-opacity:1;stroke-width:22.3376" />
|
||||
<path
|
||||
style="fill:#db5860;fill-opacity:1;stroke-width:1.16152"
|
||||
id="path936"
|
||||
d="M 256.00058,8.2104756 C 392.90373,8.2104756 503.7901,119.09685 503.7901,256 c 0,136.90315 -110.88637,247.78952 -247.78952,247.78952 C 119.09743,503.78952 8.2098955,392.90431 8.2098955,256 8.2098955,119.09569 119.09627,8.2104756 256.00058,8.2104756 Z M 454.23173,256 c 0,-109.52276 -88.7084,-198.232321 -198.23231,-198.232321 -45.84152,0 -87.84191,15.73505 -121.41667,41.75299 L 412.47991,377.41783 C 438.49785,343.84191 454.23173,301.84152 454.23173,256 Z M 256.00058,454.23231 c 45.84152,0 87.84191,-15.73504 121.41667,-41.75298 L 99.521254,134.58333 C 73.503315,168.15925 57.768265,210.15964 57.768265,256 c 0,109.52391 88.708395,198.23231 198.232315,198.23231 z" />
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 3.2 KiB |
@@ -1,121 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<svg
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/"
|
||||
xmlns:cc="http://creativecommons.org/ns#"
|
||||
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:svg="http://www.w3.org/2000/svg"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
inkscape:version="1.0.1 (3bc2e813f5, 2020-09-07)"
|
||||
height="512"
|
||||
width="512"
|
||||
sodipodi:docname="mark_pkgbuild.svg"
|
||||
xml:space="preserve"
|
||||
viewBox="0 0 512.00002 512.00002"
|
||||
y="0px"
|
||||
x="0px"
|
||||
id="Capa_1"
|
||||
version="1.1"><metadata
|
||||
id="metadata1194"><rdf:RDF><cc:Work
|
||||
rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
|
||||
rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
|
||||
id="defs1192" /><sodipodi:namedview
|
||||
inkscape:current-layer="Capa_1"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:window-y="0"
|
||||
inkscape:window-x="0"
|
||||
inkscape:cy="176.38591"
|
||||
inkscape:cx="96.230087"
|
||||
inkscape:zoom="0.58067225"
|
||||
fit-margin-bottom="0"
|
||||
fit-margin-right="0"
|
||||
fit-margin-left="0"
|
||||
fit-margin-top="0"
|
||||
showgrid="false"
|
||||
id="namedview1190"
|
||||
inkscape:window-height="739"
|
||||
inkscape:window-width="1366"
|
||||
inkscape:pageshadow="2"
|
||||
inkscape:pageopacity="0"
|
||||
guidetolerance="10"
|
||||
gridtolerance="10"
|
||||
objecttolerance="10"
|
||||
borderopacity="1"
|
||||
bordercolor="#666666"
|
||||
pagecolor="#ffffff"
|
||||
inkscape:document-rotation="0" />
|
||||
<g
|
||||
style="fill:#59a869;fill-opacity:1;stroke-width:1.00086;stroke-miterlimit:4;stroke-dasharray:none"
|
||||
transform="matrix(1.4532091,0,0,1.4469064,2.5008013,3.6009241)"
|
||||
id="g1157">
|
||||
<path
|
||||
style="fill:#59a869;fill-opacity:1;stroke-width:1.00086;stroke-miterlimit:4;stroke-dasharray:none"
|
||||
id="path1153"
|
||||
d="m 333.988,11.758 -0.42,-0.383 C 325.538,4.04 315.129,0 304.258,0 292.071,0 280.37,5.159 272.154,14.153 L 116.803,184.231 c -1.416,1.55 -2.49,3.379 -3.154,5.37 l -18.267,54.762 c -2.112,6.331 -1.052,13.333 2.835,18.729 3.918,5.438 10.23,8.685 16.886,8.685 0,0 0.001,0 0.001,0 2.879,0 5.693,-0.592 8.362,-1.76 l 52.89,-23.138 c 1.923,-0.841 3.648,-2.076 5.063,-3.626 L 336.771,73.176 C 352.937,55.479 351.69,27.929 333.988,11.758 Z m -203.607,222.489 10.719,-32.134 0.904,-0.99 20.316,18.556 -0.904,0.99 z M 314.621,52.943 182.553,197.53 162.237,178.974 294.305,34.386 c 2.583,-2.828 6.118,-4.386 9.954,-4.386 3.365,0 6.588,1.252 9.082,3.53 l 0.419,0.383 c 5.484,5.009 5.87,13.546 0.861,19.03 z" />
|
||||
<path
|
||||
style="fill:#59a869;fill-opacity:1;stroke-width:1.00086;stroke-miterlimit:4;stroke-dasharray:none"
|
||||
id="path1155"
|
||||
d="m 303.85,138.388 c -8.284,0 -15,6.716 -15,15 v 127.347 c 0,21.034 -17.113,38.147 -38.147,38.147 H 68.904 c -21.035,0 -38.147,-17.113 -38.147,-38.147 V 100.413 c 0,-21.034 17.113,-38.147 38.147,-38.147 h 131.587 c 8.284,0 15,-6.716 15,-15 0,-8.284 -6.716,-15 -15,-15 H 68.904 c -37.577,0 -68.147,30.571 -68.147,68.147 v 180.321 c 0,37.576 30.571,68.147 68.147,68.147 h 181.798 c 37.576,0 68.147,-30.571 68.147,-68.147 V 153.388 c 0.001,-8.284 -6.715,-15 -14.999,-15 z" />
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1159">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1161">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1163">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1165">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1167">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1169">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1171">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1173">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1175">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1177">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1179">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1181">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1183">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1185">
|
||||
</g>
|
||||
<g
|
||||
transform="translate(-0.757)"
|
||||
id="g1187">
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 3.9 KiB |
@@ -1,50 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<svg
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/"
|
||||
xmlns:cc="http://creativecommons.org/ns#"
|
||||
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:svg="http://www.w3.org/2000/svg"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
enable-background="new 0 0 515.91 728.5"
|
||||
height="512"
|
||||
id="Layer_1"
|
||||
version="1.1"
|
||||
viewBox="0 0 512.00003 512"
|
||||
width="512"
|
||||
xml:space="preserve"
|
||||
sodipodi:docname="repo.svg"
|
||||
inkscape:version="0.92.5 (2060ec1f9f, 2020-04-08)"><metadata
|
||||
id="metadata4874"><rdf:RDF><cc:Work
|
||||
rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
|
||||
rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><sodipodi:namedview
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#666666"
|
||||
borderopacity="1"
|
||||
objecttolerance="10"
|
||||
gridtolerance="10"
|
||||
guidetolerance="10"
|
||||
inkscape:pageopacity="0"
|
||||
inkscape:pageshadow="2"
|
||||
inkscape:window-width="1366"
|
||||
inkscape:window-height="731"
|
||||
id="namedview4872"
|
||||
showgrid="false"
|
||||
inkscape:zoom="0.4609375"
|
||||
inkscape:cx="256"
|
||||
inkscape:cy="256"
|
||||
inkscape:window-x="0"
|
||||
inkscape:window-y="0"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:current-layer="Layer_1" /><defs
|
||||
id="defs7" /><g
|
||||
id="g7397"><path
|
||||
d="m 483.79662,255.99999 c 0,124.61043 -101.98802,225.62714 -227.79665,225.62714 -125.80856,0 -227.796587,-101.01671 -227.796587,-225.62714 0,-124.61042 101.988027,-225.62713 227.796587,-225.62713 125.80863,0 227.79665,101.01671 227.79665,225.62713 z"
|
||||
id="path4878"
|
||||
style="fill:#2ca05a;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.61435276"
|
||||
inkscape:connector-curvature="0" /><path
|
||||
d="m 255.97112,65.406765 c -13.66398,33.181247 -21.90541,54.885765 -37.11848,87.080715 9.32755,9.79296 20.77665,21.19734 39.36976,34.07755 -19.98952,-8.14724 -33.62484,-16.32685 -43.81465,-24.81486 -19.46975,40.23971 -49.97323,97.55939 -111.87483,207.72442 48.65255,-27.8204 86.36704,-44.97198 121.51517,-51.51657 -1.50915,-6.42954 -2.3674,-13.38436 -2.30911,-20.64094 l 0.0578,-1.54378 c 0.7721,-30.87348 16.98686,-54.61518 36.19484,-53.00317 19.20797,1.61201 34.13808,27.96174 33.36607,58.83524 -0.14513,5.80941 -0.80663,11.39799 -1.9627,16.58135 34.76648,6.73618 72.07778,23.84385 120.07205,51.28787 -9.46363,-17.25706 -17.91061,-32.81303 -25.97719,-47.62854 -12.70607,-9.75433 -25.95929,-22.44964 -52.99323,-36.1931 18.58161,4.78229 31.88565,10.29978 42.25591,16.467 C 290.7376,150.8763 284.09609,130.77915 255.97112,65.406765 Z"
|
||||
id="path2518"
|
||||
style="fill:#ffffff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:0.8855831"
|
||||
inkscape:connector-curvature="0" /></g></svg>
|
||||
|
Before Width: | Height: | Size: 2.9 KiB |
@@ -1,122 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<svg
|
||||
xmlns:dc="http://purl.org/dc/elements/1.1/"
|
||||
xmlns:cc="http://creativecommons.org/ns#"
|
||||
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:svg="http://www.w3.org/2000/svg"
|
||||
xmlns="http://www.w3.org/2000/svg"
|
||||
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
|
||||
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
|
||||
version="1.1"
|
||||
id="Capa_1"
|
||||
x="0px"
|
||||
y="0px"
|
||||
viewBox="0 0 512.00002 512.00002"
|
||||
xml:space="preserve"
|
||||
sodipodi:docname="unmark_pkgbuild.svg"
|
||||
width="512"
|
||||
height="512"
|
||||
inkscape:version="1.0.1 (3bc2e813f5, 2020-09-07)"><metadata
|
||||
id="metadata1194"><rdf:RDF><cc:Work
|
||||
rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
|
||||
rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
|
||||
id="defs1192">
|
||||
|
||||
|
||||
</defs><sodipodi:namedview
|
||||
inkscape:document-rotation="0"
|
||||
pagecolor="#ffffff"
|
||||
bordercolor="#666666"
|
||||
borderopacity="1"
|
||||
objecttolerance="10"
|
||||
gridtolerance="10"
|
||||
guidetolerance="10"
|
||||
inkscape:pageopacity="0"
|
||||
inkscape:pageshadow="2"
|
||||
inkscape:window-width="1366"
|
||||
inkscape:window-height="739"
|
||||
id="namedview1190"
|
||||
showgrid="false"
|
||||
fit-margin-top="0"
|
||||
fit-margin-left="0"
|
||||
fit-margin-right="0"
|
||||
fit-margin-bottom="0"
|
||||
inkscape:zoom="0.58067225"
|
||||
inkscape:cx="203.118"
|
||||
inkscape:cy="164.43767"
|
||||
inkscape:window-x="0"
|
||||
inkscape:window-y="0"
|
||||
inkscape:window-maximized="1"
|
||||
inkscape:current-layer="Capa_1" />
|
||||
|
||||
<g
|
||||
id="g1159"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1161"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1163"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1165"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1167"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1169"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1171"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1173"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1175"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1177"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1179"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1181"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1183"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1185"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g1187"
|
||||
transform="translate(-0.757)">
|
||||
</g>
|
||||
<g
|
||||
id="g13014"><path
|
||||
d="M 488.31349,20.148378 487.7019,19.593117 C 476.0096,8.9590807 460.85324,3.1020243 445.02418,3.1020243 c -17.74526,0 -34.78287,7.4793447 -46.74605,20.5185437 L 172.07443,270.19395 c -2.06182,2.24712 -3.62564,4.89876 -4.59248,7.78522 L 140.8837,357.3713 c -3.07524,9.17847 -1.5318,19.32972 4.12799,27.15267 5.70494,7.88383 14.89571,12.59122 24.5874,12.59122 0,0 0.001,0 0.001,0 4.19206,0 8.28947,-0.85817 12.17575,-2.5516 L 258.788,361.01891 c 2.80004,-1.21918 5.31179,-3.00972 7.37212,-5.25684 L 492.36576,109.19013 C 515.90477,83.533616 514.08904,43.59255 488.31349,20.148378 Z M 191.8451,342.70547 l 15.60774,-46.58681 1.31629,-1.43519 29.58175,26.90185 -1.31633,1.4352 z M 460.11355,79.857008 267.8118,289.47438 238.23004,262.57253 430.5318,52.953692 c 3.76106,-4.099938 8.90831,-6.358676 14.49383,-6.358676 4.89971,0 9.59268,1.815112 13.22415,5.117676 l 0.61012,0.555259 c 7.98514,7.26188 8.54719,19.638537 1.25373,27.589055 z"
|
||||
id="path1153"
|
||||
style="fill:#59a869;fill-opacity:1;stroke-width:1.45417;stroke-miterlimit:4;stroke-dasharray:none" /><path
|
||||
d="m 444.4301,203.7323 c -12.06218,0 -21.84121,9.73663 -21.84121,21.7465 v 184.62339 c 0,30.4944 -24.91794,55.30424 -55.54515,55.30424 H 102.32958 c -30.628676,0 -55.545143,-24.80984 -55.545143,-55.30424 V 148.67742 c 0,-30.49439 24.917923,-55.30424 55.545143,-55.30424 h 191.60139 c 12.06218,0 21.84122,-9.73663 21.84122,-21.746496 0,-12.009866 -9.77904,-21.746497 -21.84122,-21.746497 H 102.32958 c -54.715176,0 -99.227587,44.32081 -99.227587,98.797233 v 261.42332 c 0,54.47644 44.513867,98.79724 99.227587,98.79724 h 264.71271 c 54.71372,0 99.22758,-44.3208 99.22758,-98.79724 V 225.4788 c 10e-4,-12.00987 -9.77759,-21.7465 -21.83977,-21.7465 z"
|
||||
id="path1155"
|
||||
style="fill:#59a869;fill-opacity:1;stroke-width:1.45417;stroke-miterlimit:4;stroke-dasharray:none" /><path
|
||||
style="fill:#db5860;stroke-width:1.16152;fill-opacity:1"
|
||||
id="path936"
|
||||
d="m 256.00057,8.2104852 c 136.90315,0 247.78952,110.8863748 247.78952,247.7895248 0,136.90315 -110.88637,247.78952 -247.78952,247.78952 C 119.09742,503.78953 8.2098842,392.90432 8.2098842,256.00001 8.2098842,119.0957 119.09626,8.2104852 256.00057,8.2104852 Z M 454.23172,256.00001 c 0,-109.52276 -88.7084,-198.232317 -198.23231,-198.232317 -45.84152,0 -87.84191,15.735046 -121.41667,41.752987 L 412.4799,377.41784 c 26.01794,-33.57592 41.75182,-75.57631 41.75182,-121.41783 z M 256.00057,454.23232 c 45.84152,0 87.84191,-15.73504 121.41667,-41.75298 l -277.896,-277.896 c -26.01794,33.57592 -41.752987,75.57631 -41.752987,121.41667 0,109.52391 88.708397,198.23231 198.232317,198.23231 z" /></g></svg>
|
||||
|
Before Width: | Height: | Size: 5.0 KiB |
@@ -1,318 +0,0 @@
|
||||
arch.action.rebuild_check.allow=Allow reinstallation check
|
||||
arch.action.rebuild_check.allow.desc=Allows to verify the need of reinstalling the package
|
||||
arch.action.rebuild_check.allow.status=Allowing reinstallation check
|
||||
arch.action.rebuild_check.allow.confirm=Allow reinstallation check for {} ?
|
||||
arch.action.rebuild_check.ignore=Ignore reinstallation check
|
||||
arch.action.rebuild_check.ignore.desc=Do not verify if the package needs to be reinstalled on the system
|
||||
arch.action.rebuild_check.ignore.status=Ignoring reinstallation check
|
||||
arch.action.rebuild_check.ignore.confirm=Ignore reinstallation check for {} ?
|
||||
arch.action.db_locked.body.l1=The system's package database is locked.
|
||||
arch.action.db_locked.body.l2=It is necessary to unlock it to continue.
|
||||
arch.action.db_locked.confirmation=Unlock and continue
|
||||
arch.action.db_locked.error=It was not possible to unlock the database.
|
||||
arch.action.db_locked.title=Database locked
|
||||
arch.action.disable_pkgbuild_edition=Unmark PKGBUILD as editable
|
||||
arch.action.disable_pkgbuild_edition.confirm=Unmark PKGBUILD of {} as editable ?
|
||||
arch.action.disable_pkgbuild_edition.desc=Do not allow the package's PKGBUILD file to be edited before updating it
|
||||
arch.action.disable_pkgbuild_edition.status=Unmarking PKGBUILD as editable
|
||||
arch.action.enable_pkgbuild_edition=Mark PKGBUILD as editable
|
||||
arch.action.enable_pkgbuild_edition.confirm=Mark PKGBUILD of {} as editable ?
|
||||
arch.action.enable_pkgbuild_edition.desc=Allows the package's PKGBUILD file to be edited before updating it
|
||||
arch.action.enable_pkgbuild_edition.status=Marking PKGBUILD as editable
|
||||
arch.action.reinstall=Reinstall
|
||||
arch.action.reinstall.desc=Tries to install the package again
|
||||
arch.action.reinstall.status=Reinstalling
|
||||
arch.action.reinstall.confirm=Do you want to reinstall {} ?
|
||||
arch.action.reinstall.error.no_apidata=It was not possible to retrieve information of {} from AUR
|
||||
arch.aur.action.edit_pkgbuild.body=Edit the PKGBUILD file of {} before continuing ?
|
||||
arch.aur.install.pgp.body=Per a instal·lar {} cal rebre les claus PGP següents
|
||||
arch.aur.install.pgp.receive_fail=Could not receive PGP key {}
|
||||
arch.aur.install.pgp.sign_fail=No s’ha pogut rebre la clau PGP {}
|
||||
arch.aur.install.pgp.substatus=S’està rebent la clau PGP {}
|
||||
arch.aur.install.pgp.success=Claus PGP rebudes i signades
|
||||
arch.aur.install.pgp.title=Claus PGP necessàries
|
||||
arch.aur.install.unknown_key.receive_error=No s’ha pogut rebre la clau pública {}
|
||||
arch.aur.install.unknown_key.status=S’està rebent la clau pública {}
|
||||
arch.aur.install.validity_check.body=Alguns dels fitxers font necessaris per a la instal·lació de {} són malmesos.
|
||||
arch.aur.install.validity_check.proceed=Voleu continuar de totes maneres? ( no es recomana )
|
||||
arch.aur.install.validity_check.title=Problemes d’integritat {}
|
||||
arch.aur.install.verifying_pgp=S’estan comprovant les claus PGP
|
||||
arch.aur.build.list_output=Checking built files
|
||||
arch.aur.sync.several_names.popup.body=The definition file (PKGBUILD) of {} configures the build of other packages
|
||||
arch.aur.sync.several_names.popup.bt_only_chosen=Build only {}
|
||||
arch.aur.sync.several_names.popup.bt_selected=Build selected too
|
||||
arch.building.package=S’està compilant el paquet {}
|
||||
arch.can_work.not_arch_distro=Only available for ArchLinux based distributions
|
||||
arch.checking.conflicts=S’està comprovant si hi ha conflictes amb {}
|
||||
arch.checking.deps=S’estan comprovant les dependències de {}
|
||||
arch.checking.missing_deps=Verificació de les dependències que falten de {}
|
||||
arch.clone=S’està clonant el dipòsit {} de l’AUR
|
||||
arch.category.remove_from_aur=Removed from AUR
|
||||
arch.config.aur=AUR packages
|
||||
arch.config.aur.tip=It allows to manage AUR packages. git must be installed.
|
||||
arch.config.aur_rebuild_detector=Check reinstallation need
|
||||
arch.config.aur_rebuild_detector.tip=It checks if packages built with old library versions require to be rebuilt. If a package needs to be rebuilt, it will be marked for update ({} must be installed)
|
||||
arch.config.aur_rebuild_detector_no_bin=Ignore binaries ({})
|
||||
arch.config.aur_rebuild_detector_no_bin.tip=If binary packages named as "package-bin" should be ignored by {} ({})
|
||||
arch.config.automatch_providers=Auto-match dependency by name
|
||||
arch.config.automatch_providers.tip=It associates automatically a package to a dependency if both names match. Otherwise all providers for a given dependency will be displayed.
|
||||
arch.config.aur_build_dir=Build directory
|
||||
arch.config.aur_build_dir.tip=It define a custom directory where the AUR packages will be built. Default: {}.
|
||||
arch.config.aur_build_only_chosen=Build only chosen
|
||||
arch.config.aur_build_only_chosen.tip=Some AUR packages have a common PKGBUILD shared with other packages and that defines build instructions for each one. This property enabled will ensure that only the chosen package will be built.
|
||||
arch.config.aur_remove_build_dir=Remove build directory
|
||||
arch.config.aur_remove_build_dir.tip=If a package's generated build directory should be removed after the operations is finished.
|
||||
arch.config.categories_exp=Categories expiration
|
||||
arch.config.categories_exp.tip=It defines the expiration time (in HOURS) of the packages categories mapping file stored in disc. Use 0 so that it is always updated during initialization.
|
||||
arch.config.clean_cache=Elimina les versions antigues
|
||||
arch.config.clean_cache.tip=Si cal eliminar les versions antigues d'un paquet emmagatzemat al disc durant la desinstal·lació
|
||||
arch.config.check_dependency_breakage=Check dependency version breakage
|
||||
arch.config.check_dependency_breakage.tip=If, during the verification of upgrade requirements, specific versions of dependencies must also be checked. Example: package A depends on version 1.0 of B.
|
||||
arch.config.edit_aur_pkgbuild=Edit PKGBUILD
|
||||
arch.config.edit_aur_pkgbuild.tip=If the PKGBUILD file of an AUR package should be displayed for editing before its installation/upgrade/downgrade
|
||||
arch.config.aur_idx_exp=Index expiration
|
||||
arch.config.aur_idx_exp.tip=It defines the period (in HOURS) for the AUR index stored in disc to be considered up to date during the initialization process. Use 0 so that it is always updated.
|
||||
arch.config.mirrors_sort_limit=Mirrors sort limit
|
||||
arch.config.mirrors_sort_limit.tip=Defines the maximum number of mirrors that will be used for speed sorting. Use 0 for no limit or leave it blank to disable sorting.
|
||||
arch.config.optimize=Optimize
|
||||
arch.config.optimize.tip=La configuració optimitzada s'utilitzarà per fer més ràpida la instal·lació, actualització i reversió dels paquets, en cas contrari s'utilitzarà la configuració del sistema.
|
||||
arch.config.pacman_mthread_download=Multithreaded download (repositories)
|
||||
arch.config.pacman_mthread_download.tip=Whether the repository packages should be downloaded with a tool that works with threads (it may be faster). pacman-mirrors must be installed.
|
||||
arch.config.prefer_repository_provider=Prefer repository dependencies
|
||||
arch.config.prefer_repository_provider.tip=Automatically picks the single package from the repositories among several external ({}) available as the provider for a given dependency
|
||||
arch.config.refresh_mirrors=Refresh mirrors on startup
|
||||
arch.config.refresh_mirrors.tip=Refresh the package mirrors once a day on startup
|
||||
arch.config.repos=Repositories packages
|
||||
arch.config.repos.tip=It allows to manage packages from the repositories set
|
||||
arch.config.suggest_optdep_uninstall=Uninstall optional dependencies
|
||||
arch.config.suggest_optdep_uninstall.tip=If the optional dependencies associated with uninstalled packages should be suggested for uninstallation. Only the optional dependencies that are not dependencies of other packages will be suggested.
|
||||
arch.config.suggest_unneeded_uninstall=Uninstall unneeded dependencies
|
||||
arch.config.suggest_unneeded_uninstall.tip=If the dependencies apparently no longer necessary associated with the uninstalled packages should be suggested for uninstallation. When this property is enabled it automatically disables the property {}.
|
||||
arch.config.suggest_optdep_select=Download optional dependencies
|
||||
arch.config.suggest_optdep_select.tip=Selects all or no optional dependencies when installing packages
|
||||
arch.config.suggestions_exp=Suggestions expiration
|
||||
arch.config.suggestions_exp.tip=It defines the period (in hours) in which the suggestions stored in disc will be considered up to date. Use 0 if you always want to update them.
|
||||
arch.config.sync_dbs=Synchronize packages databases
|
||||
arch.config.sync_dbs.tip=Synchronizes the package databases once a day before the first package installation, upgrade or downgrade. This option helps to prevent errors during these operations.
|
||||
arch.config.sync_dbs_start.tip=Synchronizes the package databases during the initialization once a day
|
||||
arch.custom_action.clean_cache=Clean cache
|
||||
arch.custom_action.clean_cache.desc=Removes all the downloade package files from the disk cache
|
||||
arch.custom_action.clean_cache.fail=An error occurred while cleaning the cache
|
||||
arch.custom_action.clean_cache.msg1=The cache is a system directory where files of old package versions are stored
|
||||
arch.custom_action.clean_cache.msg2=Cleaning it frees storage space without harming your system
|
||||
arch.custom_action.clean_cache.msg3=It also helps when there are downloaded packages with integrity issues blocking an action
|
||||
arch.custom_action.clean_cache.no_dir=The cache directory {} does not exist
|
||||
arch.custom_action.clean_cache.status=Cleaning cache
|
||||
arch.custom_action.clean_cache.success=Cache successfully cleaned !
|
||||
arch.custom_action.refresh_dbs=Synchronize package databases
|
||||
arch.custom_action.refresh_dbs.desc=Synchronizes the available packages on the repositories
|
||||
arch.custom_action.refresh_dbs.failed=It was not possible to synchronize the package databases
|
||||
arch.custom_action.refresh_mirrors=Refresh mirrors
|
||||
arch.custom_action.refresh_mirrors.desc=Allows to choose the repository mirrors and sort them by the fastest
|
||||
arch.custom_action.refresh_mirrors.failed=It was not possible to refresh the mirrors
|
||||
arch.custom_action.refresh_mirrors.location.all=All
|
||||
arch.custom_action.refresh_mirrors.location.all.tip=If this option is checked, the others will be ignored.
|
||||
arch.custom_action.refresh_mirrors.select_label=Check the desired locations
|
||||
arch.custom_action.refresh_mirrors.status.sorting=Sorting mirrors by speed
|
||||
arch.custom_action.refresh_mirrors.status.updating=Sorting mirrors by speed
|
||||
arch.custom_action.setup_snapd=Check Snaps support
|
||||
arch.custom_action.setup_snapd.desc=Checks if the Snaps support are properly enabled on the system
|
||||
snap.custom_action.setup_snapd.missing_link=Create the link {} for {}
|
||||
arch.custom_action.setup_snapd.status=Checking Snaps support
|
||||
snap.custom_action.setup_snapd.ready=Ready!
|
||||
snap.custom_action.setup_snapd.ready.body=The system is ready to work with Snaps!
|
||||
snap.custom_action.setup_snapd.required_actions=Actions required for Snaps to work correctly
|
||||
snap.custom_action.setup_snapd.service_disabled=Enable the service {}
|
||||
snap.custom_action.setup_snapd.service_inactive=Start the service {}
|
||||
arch.custom_action.upgrade_system=Quick system upgrade
|
||||
arch.custom_action.upgrade_system.desc=Tries to upgrade the system with a single pacman call
|
||||
arch.custom_action.upgrade_system.no_updates=There are no updates available
|
||||
arch.custom_action.upgrade_system.pkgs=The packages below will be upgraded
|
||||
arch.custom_action.upgrade_system.status=Upgrading system
|
||||
arch.custom_action.upgrade_system.substatus=Upgrading packages
|
||||
arch.custom_action.upgrade_system.success.line1=System successfully upgraded!
|
||||
arch.custom_action.upgrade_system.success.line2=Some changes may require a system restart to take effect.
|
||||
arch.custom_action.upgrade_system.success.line3=Restart now ?
|
||||
arch.dialog.providers.line1=There are multiple providers for some dependencies
|
||||
arch.dialog.providers.line2=Select those you want
|
||||
arch.downgrade.error=Error
|
||||
arch.downgrade.impossible=No s’ha pogut revertir la versió de {}
|
||||
arch.downgrade.install_older=S’està instal·lant la versió anterior
|
||||
arch.downgrade.reading_commits=S’estan llegint les revisions del dipòsit
|
||||
arch.downgrade.repo_pkg.no_versions=No s'ha trobat cap versió antiga al disc
|
||||
arch.downgrade.searching_stored=Cerqueu versions antigues al disc
|
||||
arch.downgrade.version_found=S’ha trobat la versió actual del paquet
|
||||
arch.aur.error.missing_root_dep={dep} is not installed and is required for installing {aur} packages as the {root} user
|
||||
arch.aur.error.add_builder_user=It was not possible to create the user {user} for building {aur} packages
|
||||
arch.info.00_pkg_build=PKGBUILD
|
||||
arch.info.00_url=URL
|
||||
arch.info.01_id=identificació
|
||||
arch.info.02_name=nom
|
||||
arch.info.03_description=descripció
|
||||
arch.info.03_version=versió
|
||||
arch.info.04_exec=Executable
|
||||
arch.info.04_orphan=orphan
|
||||
arch.info.04_orphan.true=yes
|
||||
arch.info.04_orphan.false=no
|
||||
arch.info.04_out_of_date=out of date
|
||||
arch.info.04_out_of_date.true=yes
|
||||
arch.info.04_out_of_date.false=no
|
||||
arch.info.04_popularity=popularitat
|
||||
arch.info.05_votes=vots
|
||||
arch.info.06_package_base=paquet base
|
||||
arch.info.07_maintainer=mantenidor
|
||||
arch.info.08_first_submitted=presentar per primera vegada
|
||||
arch.info.09_last_modified=última modificació
|
||||
arch.info.10_url=descàrrega uRL
|
||||
arch.info.11_pkg_build_url=uRL PKGBUILD
|
||||
arch.info.12_makedepends=dependències de compilació
|
||||
arch.info.13_dependson=dependències d'instal·lació
|
||||
arch.info.13_pkg_build=PKGBUILD
|
||||
arch.info.14_installed_files=arxius instal·lats
|
||||
arch.info.14_optdepends=dependències opcionals
|
||||
arch.info.15_checkdepends=comprovació de dependències
|
||||
arch.info.arch=arc
|
||||
arch.info.arch.any=cap
|
||||
arch.info.architecture=arquitectura
|
||||
arch.info.architecture.any=cap
|
||||
arch.info.build date=data de creació
|
||||
arch.info.conflicts with=conflictes amb
|
||||
arch.info.depends=depèn
|
||||
arch.info.depends on=depén de
|
||||
arch.info.description=descripció
|
||||
arch.info.download size=Download size
|
||||
arch.info.install date=data d'instal·lació
|
||||
arch.info.install reason=instal·lar raó
|
||||
arch.info.install reason.explicitly installed=instal·lat de forma explícita
|
||||
arch.info.install reason.installed as a dependency for another package=la dependència d'un altre paquet
|
||||
arch.info.install script=script d'instal·lació
|
||||
arch.info.install script.no=no
|
||||
arch.info.installed files=arxius instal·lats
|
||||
arch.info.installed size=mida instal·lat
|
||||
arch.info.last_modified=última modificació
|
||||
arch.info.license=llicència
|
||||
arch.info.licenses=llicències
|
||||
arch.info.licenses.custom=costum
|
||||
arch.info.name=nom
|
||||
arch.info.optdepends=dependències opcionals
|
||||
arch.info.optional deps=dependències opcionals
|
||||
arch.info.optional for=per opcional
|
||||
arch.info.options=opcions
|
||||
arch.info.packager=empaquetador
|
||||
arch.info.packager.unknown packager=desconegut
|
||||
arch.info.pkgdesc=descripció
|
||||
arch.info.pkgname=nom
|
||||
arch.info.pkgrel=alliberament
|
||||
arch.info.pkgver=versió
|
||||
arch.info.provides=proporciona
|
||||
arch.info.replaces=substitueix
|
||||
arch.info.required by=requerit per
|
||||
arch.info.source=font
|
||||
arch.info.url=uRL
|
||||
arch.info.validated by=validat per
|
||||
arch.info.validated by.signature=signatura
|
||||
arch.info.validpgpkeys=Les claus PGP vàlids
|
||||
arch.info.version=versió
|
||||
arch.install.aur.root_error.body=No està permès instal·lar, actualitzar ni revaloritzar un paquet com a usuari root.
|
||||
arch.install.aur.root_error.title=No es permet l’acció
|
||||
arch.install.aur.unknown_key.title=Clau pública necessària
|
||||
arch.install.aur.unknown_key.body=Per a continuar amb la instal·lació de {} cal confiar en la clau pública següent {}
|
||||
arch.install.conflict.popup.body=Les aplicacions {} estan en conflicte. Heu de desinstal·lar una per a instal·lar l’altra. Voleu continuar?
|
||||
arch.install.conflict.popup.title=S’ha detectat un conflicte
|
||||
arch.install.dep_not_found.body.l1=No s’ha trobat la dependència requerida {dep}{source} a l’AUR ni als dipòsits
|
||||
arch.install.dep_not_found.body.l2=It might be a package database synchronization problem.
|
||||
arch.install.dep_not_found.body.l3=Operation cancelled.
|
||||
arch.install.dep_not_found.title=No s’ha trobat la dependència
|
||||
arch.install.dependency.install=S’està instal·lant el paquet depenent {}
|
||||
arch.install.dependency.install.error=Could not install the dependent packages: {}. Installation of {} aborted.
|
||||
arch.install.error.conflicting_files=The package {} wants to overwrite files from other installed packages
|
||||
arch.install.error.conflicting_files.proceed=Allow
|
||||
arch.install.error.conflicting_files.stop=Cancel installation
|
||||
arch.install.optdep.error=Could not install the optional packages: {}
|
||||
arch.install.optdeps.request.body=Check the optional associated packages below that you want to install
|
||||
arch.install.optdeps.request.success={pkg} was successfully installed !
|
||||
arch.install.optdeps.request.title=Dependències opcionals
|
||||
arch.installing.package=S’està instal·lant el paquet {}
|
||||
arch.checking_unnecessary_deps=Checking if there are packages no longer needed
|
||||
arch.makepkg.optimizing=Optimitzant la recopilació
|
||||
arch.missing_deps.body=The following dependencies ({deps}) will be installed
|
||||
arch.missing_deps.title=Dependències mancants
|
||||
arch.missing_deps_found=Dependències mancants per a {}
|
||||
arch.mthread_downloaded.error.cache_dir=It was not possible to create the cache directory {}
|
||||
arch.mthread_downloaded.error.cancelled=Operation cancelled
|
||||
arch.optdeps.checking=S’estan comprovant les dependències opcionals de {}
|
||||
arch.package.requires_rebuild=It needs to be reinstalled
|
||||
arch.providers=providers
|
||||
arch.substatus.conflicts=Checking for conflicts
|
||||
arch.substatus.disk_space=Checking available disk space
|
||||
arch.substatus.integrity=Checking packages integrity
|
||||
arch.substatus.keyring=Checking keyring
|
||||
arch.substatus.loading_files=Loading package files
|
||||
arch.substatus.pre_hooks=Running pre-transaction hooks
|
||||
arch.substatus.retrieve_pkgs=Retrieving packages
|
||||
arch.sync.dep_breakage.reason={} requires {}
|
||||
arch.sync_databases.substatus=Synchronizing package databases
|
||||
arch.sync_databases.substatus.error=It was not possible to synchronize the package database
|
||||
arch.sync_databases.substatus.synchronized=Synchronized
|
||||
arch.task.aur.index.status=Generating local AUR index
|
||||
arch.task.aur.index.substatus.checking=Checking for updates
|
||||
arch.task.aur.index.substatus.download=Downloading the AUR index
|
||||
arch.task.aur.index.substatus.error.download=Connection error while downloading the index
|
||||
arch.task.aur.index.substatus.error.no_data=Error: empty index
|
||||
arch.task.aur.index.substatus.gen_index=Generating index
|
||||
arch.task.checking_settings=Checking settings
|
||||
arch.task.disabled=Disabled
|
||||
arch.task.disk_cache=Indexing packages data
|
||||
arch.task.disk_cache.checking=Checking index
|
||||
arch.task.disk_cache.indexed=Indexed
|
||||
arch.task.disk_cache.indexing=Indexing
|
||||
arch.task.disk_cache.reading_files=Reading files
|
||||
arch.task.disk_cache.waiting_aur_index=Waiting {}
|
||||
arch.task.mirrors=Refreshing mirrors
|
||||
arch.task.mirrors.cached=Refreshed
|
||||
arch.task.optimizing=Optimizing {}
|
||||
arch.task.sync_sb.status=Actualitzen {}
|
||||
arch.uninstall.clean_cached.error=No s'ha pogut eliminar {} versions antigues que es troba al disc
|
||||
arch.uninstall.clean_cached.substatus=Eliminació de versions antigues del disc
|
||||
arch.uninstall.error.hard_dep_in_hold=It is not possible to uninstall {} because one of its dependencies is marked as "InHold"
|
||||
arch.uninstall.required_by=The packages ({no}) below depend on {pkgs} to work properly
|
||||
arch.uninstall.required_by.warn=It is necessary to uninstall them as well to proceed
|
||||
arch.uninstall.unnecessary.all=The following {} packages will be uninstalled
|
||||
arch.uninstall.unnecessary.cancel=Keep
|
||||
arch.uninstall.unnecessary.l1=Packages successfully uninstalled!
|
||||
arch.uninstall.unnecessary.l2=The packages below seem to be no longer necessary
|
||||
arch.uninstall.unnecessary.proceed=Uninstall
|
||||
arch.uninstalling.conflict=Uninstalling conflicting packages
|
||||
arch.uninstalling.conflict.fail=It was not possible to uninstall the conflicting packages: {}
|
||||
arch.update.disabled.tooltip=This package can oly be upgrade through the action "Quick system upgrade"
|
||||
arch.update_summary.conflict_between=Conflict between {} and {}
|
||||
arch.update_summary.to_install.dep_conflict=Conflict between the dependencies {} and {}
|
||||
arch.update_summary.to_update.conflicts_dep=Conflicts with the dependency {} of {}
|
||||
arch.update_summary.to_update.dep_conflicts=Dependency {} conflicts with {}
|
||||
arch.upgrade.caching_pkgs_data=Caching updates data
|
||||
arch.upgrade.error.conflicting_files=Some of the packages being upgraded want to overwrite files of another installed packages
|
||||
arch.upgrade.error.dep_breakage=Some dependency breakage issues have been detected
|
||||
arch.upgrade.error.dep_breakage.item=The new version of {} breaks the dependency {} required by the installed version of {}
|
||||
arch.upgrade.error.dep_breakage.proceed=Proceed anyway
|
||||
arch.upgrade.error.dep_breakage.stop=Cancel upgrade
|
||||
arch.upgrade.conflicting_files.proceed=Allow and continue
|
||||
arch.upgrade.conflicting_files.stop=Cancel upgrading
|
||||
arch.upgrade.fail=Package {} upgrade failed
|
||||
arch.upgrade.mthreaddownload.fail=It was not possible to download all packages for upgrading
|
||||
arch.upgrade.success=Package {} successfully upgraded
|
||||
arch.upgrade.upgrade_aur_pkgs=Upgrading AUR packages
|
||||
arch.upgrade.upgrade_repo_pkgs=Upgrading packages from repositories
|
||||
arch.warning.disabled=Sembla que no s’ha instal·lat {}. No podreu gestionar paquets Arch/AUR.
|
||||
arch.warning.aur_missing_dep={} seems not to be installed. It will not be possible to manage AUR packages.
|
||||
arch_repo.history.1_version=versió
|
||||
arch_repo.history.2_release=publicació
|
||||
arch_repo.history.3_date=data
|
||||
category.orphan=orphan
|
||||
category.out_of_date=out of date
|
||||
aur.history.1_version=versió
|
||||
aur.history.2_release=publicació
|
||||
aur.history.3_date=data
|
||||
gem.arch.info=Software packages available for distributions based on Arch Linux
|
||||
gem.arch.label=Arch
|
||||
gem.arch.type.arch_repo.label=Arch - Dipòsit
|
||||
gem.arch.type.aur.label=Arch - AUR
|
||||
@@ -1,316 +0,0 @@
|
||||
arch.action.rebuild_check.allow=Überprüfung einer Neuinstallation zulassen
|
||||
arch.action.rebuild_check.allow.desc=Ermöglicht die Überprüfung, ob eine Neuinstallation des Pakets erforderlich ist
|
||||
arch.action.rebuild_check.allow.status=Überprüfung einer Neuinstallation zulassen
|
||||
arch.action.rebuild_check.allow.confirm=Überprüfung der Neuinstallation für {} zulassen?
|
||||
arch.action.rebuild_check.ignore=Neuinstallationsprüfung ignorieren
|
||||
arch.action.rebuild_check.ignore.desc=Nicht überprüfen, ob das Paket auf dem System neu installiert werden muss
|
||||
arch.action.rebuild_check.ignore.status=Ignoriere Neuinstallationsprüfung
|
||||
arch.action.rebuild_check.ignore.confirm=Neuinstallationsprüfung für {} ignorieren?
|
||||
arch.action.db_locked.body.l1=Die Paketdatenbank des Systems ist gesperrt.
|
||||
arch.action.db_locked.body.l2=Um fortzufahren, müssen Sie sie entsperren.
|
||||
arch.action.db_locked.confirmation=Entsperren und fortfahren
|
||||
arch.action.db_locked.error=Es war nicht möglich, die Datenbank zu entsperren.
|
||||
arch.action.db_locked.title=Datenbank gesperrt
|
||||
arch.action.disable_pkgbuild_edition=Markierung von PKGBUILD als bearbeitbar aufheben
|
||||
arch.action.disable_pkgbuild_edition.confirm=Markierung des PKGBUILDs von {} als bearbeitbar aufheben?
|
||||
arch.action.disable_pkgbuild_edition.desc=Die Bearbeitung der PKGBUILD-Datei des Pakets ist nicht erlaubt, bevor es aktualisiert wird
|
||||
arch.action.disable_pkgbuild_edition.status=PKGBUILD nicht mehr als bearbeitbar markieren
|
||||
arch.action.enable_pkgbuild_edition=PKGBUILD als bearbeitbar markieren
|
||||
arch.action.enable_pkgbuild_edition.confirm=PKGBUILD von {} als bearbeitbar markieren?
|
||||
arch.action.enable_pkgbuild_edition.desc=Ermöglicht die Bearbeitung der PKGBUILD-Datei des Pakets, bevor es aktualisiert wird
|
||||
arch.action.enable_pkgbuild_edition.status=Markierung von PKGBUILD als bearbeitbar
|
||||
arch.action.reinstall=Erneut installieren
|
||||
arch.action.reinstall.desc=Versucht, das Paket erneut zu installieren
|
||||
arch.action.reinstall.status=Neuinstallation
|
||||
arch.action.reinstall.confirm=Möchten Sie {} neu installieren?
|
||||
arch.action.reinstall.error.no_apidata=Es war nicht möglich, Informationen über {} aus dem AUR abzurufen
|
||||
arch.aur.action.edit_pkgbuild.body=Bearbeiten Sie die PKGBUILD-Datei von {}, bevor Sie fortfahren?
|
||||
arch.aur.install.pgp.body=Um {} zu installieren sind die folgenden PGP-Schlüssel notwendig
|
||||
arch.aur.install.pgp.receive_fail=Konnte den PGP-Schlüssel {} nicht erhalten
|
||||
arch.aur.install.pgp.sign_fail=Konnte den PGP-Schlüssel {} nicht signieren
|
||||
arch.aur.install.pgp.substatus=Erhalte PGP-Schlüssel {}
|
||||
arch.aur.install.pgp.success=PGP-Schlüssel erhalten und signiert
|
||||
arch.aur.install.pgp.title=PGP-Schlüssel erforderlich
|
||||
arch.aur.install.unknown_key.receive_error=Der öffentliche Schlüssel {} konnte nicht emfangen werden
|
||||
arch.aur.install.unknown_key.status=Empfangen des öffentlichen Schlüssels {}
|
||||
arch.aur.install.validity_check.body=Einige der für die {} Installation benötigten Quelldateien sind nicht intakt.
|
||||
arch.aur.install.validity_check.proceed=Möchten Sie trotzdem fortfahren? ( nicht empfohlen )
|
||||
arch.aur.install.validity_check.title=Integritätsprobleme {}
|
||||
arch.aur.install.verifying_pgp=Verifizierung von PGP-Schlüsseln
|
||||
arch.aur.build.list_output=Überprüfung der erstellten Dateien
|
||||
arch.aur.sync.several_names.popup.body=Die Definitionsdatei (PKGBUILD) von {} konfiguriert den Bau von anderen Paketen
|
||||
arch.aur.sync.several_names.popup.bt_only_chosen=Nur Bau von {}
|
||||
arch.aur.sync.several_names.popup.bt_selected=Bau is auch ausgewählt
|
||||
arch.building.package=Bau des Pakets {}
|
||||
arch.can_work.not_arch_distro=Nur verfügbar für ArchLinux-basierte Distributionen
|
||||
arch.checking.conflicts=Überprüfung auf mögliche Konflikte mit {}
|
||||
arch.checking.deps=Überprüfung der {} Abhängigkeiten
|
||||
arch.checking.missing_deps=Verifizierung der fehlenden Abhängigkeiten von {}
|
||||
arch.clone=Klonen des AUR-Repositorys {}
|
||||
arch.category.remove_from_aur=Aus AUR entfernt
|
||||
arch.config.aur=AUR-Pakete
|
||||
arch.config.aur.tip=Ermöglicht die Verwaltung von AUR-Paketen. git muss installiert sein.
|
||||
arch.config.aur_rebuild_detector=Überprüfung der Notwendigkeit einer Neuinstallation
|
||||
arch.config.aur_rebuild_detector.tip=Es wird geprüft, ob Pakete, die mit alten Bibliotheksversionen gebaut wurden, neu gebaut werden müssen. Wenn ein Paket neu gebaut werden muss, wird es zur Aktualisierung markiert ({} muss installiert sein)
|
||||
arch.config.aur_rebuild_detector_no_bin=Binärpakete ignorieren ({})
|
||||
arch.config.aur_rebuild_detector_no_bin.tip=Ob Binärpakete mit dem Namen "package-bin" von {} ignoriert werden sollen ({})
|
||||
arch.config.automatch_providers=Automatische Übereinstimmung von Abhängigkeiten nach Namen
|
||||
arch.config.automatch_providers.tip=Assoziiert automatisch ein Paket mit einer Abhängigkeit, wenn beide Namen übereinstimmen. Andernfalls werden alle Anbieter für eine bestimmte Abhängigkeit angezeigt.
|
||||
arch.config.aur_build_dir=Bauverzeichnis
|
||||
arch.config.aur_build_dir.tip=Definiert ein benutzerdefiniertes Verzeichnis, in dem die AUR-Pakete gebaut werden sollen. Standard: {}.
|
||||
arch.config.aur_build_only_chosen=Nur ausgewählte bauen
|
||||
arch.config.aur_build_only_chosen.tip=Einige AUR-Pakete haben ein gemeinsames PKGBUILD, das mit anderen Paketen geteilt wird und das die Bauanweisungen für jedes Paket definiert. Die Aktivierung dieser Eigenschaft stellt sicher, dass nur das ausgewählte Paket gebaut wird.
|
||||
arch.config.aur_remove_build_dir=Bauverzeichnis entfernen
|
||||
arch.config.aur_remove_build_dir.tip=Ob das erzeugte Bauverzeichnis eines Pakets nach Abschluss der Operationen entfernt werden soll.
|
||||
arch.config.categories_exp=Gültigkeitszeitraum der Kategorien
|
||||
arch.config.categories_exp.tip=Legt den Gültigkeitszeitraum (in Stunden) der auf dem Datenträger gespeicherten Paketkategorien-Zuordnungsdatei fest. Verwenden Sie 0, damit die Datei während der Initialisierung immer aktualisiert wird.
|
||||
arch.config.clean_cache=Alte Versionen entfernen
|
||||
arch.config.clean_cache.tip=Legt fest, ob alte Versionen eines Pakets, die auf dem Datenträger gespeichert sind, während der Deinstallation entfernt werden sollen.
|
||||
arch.config.check_dependency_breakage=Bruch von Abhängigkeitsversionen prüfen
|
||||
arch.config.check_dependency_breakage.tip=Ob bei der Überprüfung der Upgrade-Anforderungen auch bestimmte Versionen von Abhängigkeiten überprüft werden müssen. Beispiel: Paket A hängt von der Version 1.0 von B ab.
|
||||
arch.config.edit_aur_pkgbuild=PKGBUILD bearbeiten
|
||||
arch.config.edit_aur_pkgbuild.tip=Ob die PKGBUILD-Datei eines AUR-Pakets vor dessen Installation/Upgrade/Downgrade zur Bearbeitung angezeigt werden soll
|
||||
arch.config.aur_idx_exp=Gültigkeitszeitraum des Index
|
||||
arch.config.aur_idx_exp.tip=Legt den Gültigkeitszeitraum (in Stunden) für den, auf dem Datenträger gespeicherten, AUR-Index fest, währenddessen er im Initialisierungsprozesses als aktuell angesehen wird. Verwenden Sie 0, damit er immer aktualisiert wird.
|
||||
arch.config.mirrors_sort_limit=Sortiergrenze der Spiegel
|
||||
arch.config.mirrors_sort_limit.tip=Legt die maximale Anzahl von Spiegeln fest, die für die Schnellsortierung verwendet werden sollen. Verwenden Sie 0 für keine Begrenzung oder lassen Sie es leer, um die Sortierung zu deaktivieren.
|
||||
arch.config.optimize=Optimieren
|
||||
arch.config.optimize.tip=Optimierte Einstellungen werden verwendet, um die Installation von Paketen, Upgrades und Downgrades zu beschleunigen, ansonsten werden die Systemeinstellungen verwendet
|
||||
arch.config.pacman_mthread_download=Paralleles Herunterladen (Repositories)
|
||||
arch.config.pacman_mthread_download.tip=Ob die Repository-Pakete mit einem Werkzeug heruntergeladen werden sollen, das mit Threads arbeitet (es kann schneller sein). pacman-mirrors muss installiert sein.
|
||||
arch.config.prefer_repository_provider=Repository-Abhängigkeiten bevorzugen
|
||||
arch.config.prefer_repository_provider.tip=Wählt automatisch ein einzelnes Paket aus den Repositories unter mehreren externen ({}), die als Anbieter für eine bestimmte Abhängigkeit verfügbar sind
|
||||
arch.config.refresh_mirrors=Spiegel beim Start aktualisieren
|
||||
arch.config.refresh_mirrors.tip=Aktualisiert die Paketspiegel einmal am Tag beim Start
|
||||
arch.config.repos=Repositorie-Pakete
|
||||
arch.config.repos.tip=Ermöglicht die Verwaltung von Paketen aus den Repositories
|
||||
arch.config.suggest_optdep_uninstall=Optionale Abhängigkeiten deinstallieren
|
||||
arch.config.suggest_optdep_uninstall.tip=Ob die optionalen Abhängigkeiten, die mit deinstallierten Paketen verbunden sind, zur Deinstallation vorgeschlagen werden sollen. Es werden nur die optionalen Abhängigkeiten vorgeschlagen, die keine Abhängigkeiten von anderen Paketen sind.
|
||||
arch.config.suggest_unneeded_uninstall=Nicht benötigte Abhängigkeiten deinstallieren
|
||||
arch.config.suggest_unneeded_uninstall.tip=Ob die Abhängigkeiten, die mit den deinstallierten Paketen verbunden sind und offensichtlich nicht mehr benötigt werden, zur Deinstallation vorgeschlagen werden sollen. Wenn diese Eigenschaft aktiviert ist, wird die Eigenschaft {} automatisch deaktiviert.
|
||||
arch.config.suggestions_exp=Gültigkeitszeitraum der Vorschläge
|
||||
arch.config.suggestions_exp.tip=Legt den Gültigkeitszeitraum (in Stunden) fest, in dem die, auf dem Datenträger gespeicherten, Vorschläge als aktuell angesehen werden. Verwenden Sie 0, wenn Sie sie immer aktualisieren wollen.
|
||||
arch.config.sync_dbs=Paketdatenbanken synchronisieren
|
||||
arch.config.sync_dbs.tip=Synchronisiert die Paketdatenbanken einmal pro Tag vor der ersten Paketinstallation, dem ersten Upgrade oder Downgrade. Diese Option hilft, Fehler während dieser Vorgänge zu vermeiden.
|
||||
arch.config.sync_dbs_start.tip=Synchronisiert die Paketdatenbanken während der Initialisierung einmal pro Tag
|
||||
arch.custom_action.clean_cache=Cache bereinigen
|
||||
arch.custom_action.clean_cache.desc=Entfernt alle heruntergeladenen Paketdateien aus dem Datenträger-Cache
|
||||
arch.custom_action.clean_cache.fail=Beim Bereinigen des Caches ist ein Fehler aufgetreten
|
||||
arch.custom_action.clean_cache.msg1=Der Cache ist ein Systemverzeichnis, in dem Dateien mit alten Paketversionen gespeichert werden.
|
||||
arch.custom_action.clean_cache.msg2=Das Bereinigen des Caches gibt Speicherplatz frei, ohne Ihr System zu beschädigen.
|
||||
arch.custom_action.clean_cache.msg3=Es hilft auch, wenn heruntergeladene Pakete mit Integritätsproblemen eine Aktion blockieren
|
||||
arch.custom_action.clean_cache.no_dir=Das Cache-Verzeichnis {} existiert nicht
|
||||
arch.custom_action.clean_cache.status=Bereinigung des Caches
|
||||
arch.custom_action.clean_cache.success=Cache erfolgreich bereinigt!
|
||||
arch.custom_action.refresh_dbs=Paketdatenbanken synchronisieren
|
||||
arch.custom_action.refresh_dbs.desc=Synchronisiert die verfügbaren Pakete in den Repositories
|
||||
arch.custom_action.refresh_dbs.failed=Es war nicht möglich, die Paketdatenbanken zu synchronisieren
|
||||
arch.custom_action.refresh_mirrors=Spiegel aktualisieren
|
||||
arch.custom_action.refresh_mirrors.desc=Ermöglicht die Auswahl der Repository-Spiegel und sortiert sie nach dem schnellsten
|
||||
arch.custom_action.refresh_mirrors.failed=Es war nicht möglich, die Spiegel zu aktualisieren
|
||||
arch.custom_action.refresh_mirrors.location.all=Alle
|
||||
arch.custom_action.refresh_mirrors.location.all.tip=Wenn diese Option markiert ist, werden die anderen ignoriert.
|
||||
arch.custom_action.refresh_mirrors.select_label=Markieren Sie die gewünschten Speicherorte
|
||||
arch.custom_action.refresh_mirrors.status.sorting=Sortierung der Spiegel nach Geschwindigkeit
|
||||
arch.custom_action.refresh_mirrors.status.updating=Aktualisierung der Spiegel
|
||||
arch.custom_action.setup_snapd=Snaps-Unterstützung prüfen
|
||||
arch.custom_action.setup_snapd.desc=Überprüft, ob die Snaps-Unterstützung auf dem System richtig aktiviert ist
|
||||
snap.custom_action.setup_snapd.missing_link=Erstellen Sie den Link {} für {}
|
||||
arch.custom_action.setup_snapd.status=Überprüfung der Snaps-Unterstützung
|
||||
snap.custom_action.setup_snapd.ready=Bereit!
|
||||
snap.custom_action.setup_snapd.ready.body=Das System ist bereit für die Arbeit mit Snaps!
|
||||
snap.custom_action.setup_snapd.required_actions=Erforderliche Aktionen, damit Snaps korrekt funktionieren
|
||||
snap.custom_action.setup_snapd.service_disabled=Aktiviere den Dienst {}
|
||||
snap.custom_action.setup_snapd.service_inactive=Starte den Dienst {}
|
||||
arch.custom_action.upgrade_system=Schnelles System-Upgrade
|
||||
arch.custom_action.upgrade_system.desc=Versucht, das System mit einem einzigen pacman-Aufruf upzugraden
|
||||
arch.custom_action.upgrade_system.no_updates=Es sind keine Aktualisierungen verfügbar
|
||||
arch.custom_action.upgrade_system.pkgs=Die folgenden Pakete werden upgegradet
|
||||
arch.custom_action.upgrade_system.status=Upgraden des Systems
|
||||
arch.custom_action.upgrade_system.substatus=Upgraden der Pakete
|
||||
arch.custom_action.upgrade_system.success.line1=System erfolgreich upgegradet!
|
||||
arch.custom_action.upgrade_system.success.line2=Einige Änderungen erfordern möglicherweise einen Neustart des Systems, um wirksam zu werden.
|
||||
arch.custom_action.upgrade_system.success.line3=Jetzt neustarten?
|
||||
arch.dialog.providers.line1=Für einige Abhängigkeiten gibt es mehrere Anbieter
|
||||
arch.dialog.providers.line2=Wählen Sie die gewünschten aus
|
||||
arch.downgrade.error=Fehler
|
||||
arch.downgrade.impossible=Es ist nicht möglich, ein Downgrade von {} durchzuführen
|
||||
arch.downgrade.install_older=Installation einer älteren Version
|
||||
arch.downgrade.reading_commits=Lesen der Repository-Commits
|
||||
arch.downgrade.repo_pkg.no_versions=Keine alte Version auf dem Datenträger gefunden
|
||||
arch.downgrade.searching_stored=Suche nach alten Versionen auf dem Datenträger
|
||||
arch.downgrade.version_found=Aktuelle Paketversion gefunden
|
||||
arch.aur.error.missing_root_dep={dep} ist nicht installiert und wird für die Installation von {aur} Paketen als {root} Benutzer benötigt
|
||||
arch.aur.error.add_builder_user=Es war nicht möglich, den Benutzer {user} für die Erzeugung von {aur}-Paketen zu erstellen
|
||||
arch.info.00_pkg_build=pkgbuild
|
||||
arch.info.00_url=URL
|
||||
arch.info.01_id=ID
|
||||
arch.info.02_name=Name
|
||||
arch.info.03_description=Beschreibung
|
||||
arch.info.03_version=Version
|
||||
arch.info.04_exec=Ausführbar
|
||||
arch.info.04_orphan=verwaist
|
||||
arch.info.04_orphan.true=ja
|
||||
arch.info.04_orphan.false=nein
|
||||
arch.info.04_out_of_date=veraltet
|
||||
arch.info.04_out_of_date.true=ja
|
||||
arch.info.04_out_of_date.false=nein
|
||||
arch.info.04_popularity=Popularität
|
||||
arch.info.05_votes=Stimmen
|
||||
arch.info.06_package_base=Paketbasis
|
||||
arch.info.07_maintainer=Verwalter
|
||||
arch.info.08_first_submitted=zuerst eingereicht
|
||||
arch.info.09_last_modified=zuletzt geändert
|
||||
arch.info.10_url=URL herunterladen
|
||||
arch.info.11_pkg_build_url=URL pkgbuild
|
||||
arch.info.12_makedepends=Kompilierungs-Abhängigkeiten
|
||||
arch.info.13_dependson=Installations-Abhängigkeiten
|
||||
arch.info.13_pkg_build=pkgbuild
|
||||
arch.info.14_installed_files=Installierte Dateien
|
||||
arch.info.14_optdepends=optionale Abhängigkeiten
|
||||
arch.info.15_checkdepends=Überprüfung von Abhängigkeiten
|
||||
arch.info.arch=Architektur
|
||||
arch.info.arch.any=beliebig
|
||||
arch.info.architecture=Architektur
|
||||
arch.info.architecture.any=beliebig
|
||||
arch.info.build date=Erstellungsdatum
|
||||
arch.info.conflicts with=Konflikte mit
|
||||
arch.info.depends=hängt ab
|
||||
arch.info.depends on=hängt ab von
|
||||
arch.info.description=Beschreibung
|
||||
arch.info.download size=Download-Größe
|
||||
arch.info.install date=Installationsdatum
|
||||
arch.info.install reason=Installationsgrund
|
||||
arch.info.install reason.explicitly installed=explizit installiert
|
||||
arch.info.install reason.installed as a dependency for another package=Abhängigkeit von einem anderen Paket
|
||||
arch.info.install script=Skript installieren
|
||||
arch.info.install script.no=nein
|
||||
arch.info.installed files=installierte Dateien
|
||||
arch.info.installed size=installierte Größe
|
||||
arch.info.last_modified=zuletzt geändert
|
||||
arch.info.license=Lizenz
|
||||
arch.info.licenses=Lizenzen
|
||||
arch.info.licenses.custom=benutzerdefiniert
|
||||
arch.info.name=Name
|
||||
arch.info.optdepends=optionale Abhängigkeiten
|
||||
arch.info.optional deps=optionale Abhängigkeiten
|
||||
arch.info.optional for=optional für
|
||||
arch.info.options=Optionen
|
||||
arch.info.packager=Packer
|
||||
arch.info.packager.unknown packager=Unbekannt
|
||||
arch.info.pkgdesc=Beschreibung
|
||||
arch.info.pkgname=Name
|
||||
arch.info.pkgrel=Veröffentlichung
|
||||
arch.info.pkgver=Version
|
||||
arch.info.provides=bietet
|
||||
arch.info.replaces=ersetzt
|
||||
arch.info.required by=benötigt von
|
||||
arch.info.source=Quelle
|
||||
arch.info.url=URL
|
||||
arch.info.validated by=bestätigt von
|
||||
arch.info.validated by.signature=Unterschrift
|
||||
arch.info.validpgpkeys=gültig PGP-Schlüssel
|
||||
arch.info.version=Version
|
||||
arch.install.aur.root_error.body=Es ist nicht erlaubt, ein Paket als Root-Benutzer zu installieren, up- oder downzugraden
|
||||
arch.install.aur.root_error.title=Aktion nicht erlaubt
|
||||
arch.install.aur.unknown_key.body=Um die {} Installation fortzusetzen, ist es notwendig, dem folgenden öffentlichen Schlüssel zu vertrauen {}
|
||||
arch.install.aur.unknown_key.title=Öffentlicher Schlüssel erforderlich
|
||||
arch.install.conflict.popup.body=Die Anwendungen {} stehen in Konflikt. Sie müssen eine deinstallieren, um die andere zu installieren. Fortfahren?
|
||||
arch.install.conflict.popup.title=Konflikt erkannt
|
||||
arch.install.dep_not_found.body.l1=Die erforderliche Abhängigkeit {dep}{source} wurde weder in den Repositories noch im AUR gefunden.
|
||||
arch.install.dep_not_found.body.l2=Es könnte sich um ein Problem bei der Synchronisierung der Paketdatenbank handeln.
|
||||
arch.install.dep_not_found.body.l3=Vorgang abgebrochen.
|
||||
arch.install.dep_not_found.title=Abhängigkeit nicht gefunden
|
||||
arch.install.dependency.install=Installation der Paketabhängigkeit {}
|
||||
arch.install.dependency.install.error=Die abhängigen Pakete konnten nicht installiert werden: {}. Die Installation von {} wurde abgebrochen.
|
||||
arch.install.error.conflicting_files=Das Paket {} will Dateien von anderen installierten Paketen überschreiben
|
||||
arch.install.error.conflicting_files.proceed=Erlauben
|
||||
arch.install.error.conflicting_files.stop=Installation abbrechen
|
||||
arch.install.optdep.error=Die optionalen Pakete konnten nicht installiert werden: {}
|
||||
arch.install.optdeps.request.body=Überprüfen Sie die folgenden optionalen Pakete, die Sie installieren möchten
|
||||
arch.install.optdeps.request.success={pkg} wurde erfolgreich installiert!
|
||||
arch.install.optdeps.request.title=Optionale Abhängigkeiten
|
||||
arch.installing.package=Installation des Pakets {}
|
||||
arch.checking_unnecessary_deps=Überprüfung, ob es Pakete gibt, die nicht mehr benötigt werden
|
||||
arch.makepkg.optimizing=Optimierung der Kompilierung
|
||||
arch.missing_deps.body=Die folgenden Abhängigkeiten ({deps}) werden installiert
|
||||
arch.missing_deps.title=Fehlende Abhängigkeiten
|
||||
arch.missing_deps_found=Fehlende Abhängigkeiten für {}
|
||||
arch.mthread_downloaded.error.cache_dir=Es war nicht möglich, das Cache-Verzeichnis {} zu erstellen
|
||||
arch.mthread_downloaded.error.cancelled=Vorgang abgebrochen
|
||||
arch.optdeps.checking=Überprüfung der optionalen Abhängigkeiten für {}
|
||||
arch.package.requires_rebuild=Es muss neu installiert werden
|
||||
arch.providers=Anbieter
|
||||
arch.substatus.conflicts=Überprüfung auf Konflikte
|
||||
arch.substatus.disk_space=Überprüfung des verfügbaren Speicherplatzes
|
||||
arch.substatus.integrity=Überprüfung der Paketintegrität
|
||||
arch.substatus.keyring=Überprüfung des Schlüsselbundes
|
||||
arch.substatus.loading_files=Laden von Paketdateien
|
||||
arch.substatus.pre_hooks=Ausführen von Pre-Transaktions-Hooks
|
||||
arch.substatus.retrieve_pkgs=Abrufen von Paketen
|
||||
arch.sync.dep_breakage.reason={} benötigt {}
|
||||
arch.sync_databases.substatus=Synchronisierung der Paketdatenbanken
|
||||
arch.sync_databases.substatus.error=Es war nicht möglich, die Paketdatenbank zu synchronisieren
|
||||
arch.sync_databases.substatus.synchronized=Synchronisiert
|
||||
arch.task.aur.index.status=Generierung des lokalen AUR-Index
|
||||
arch.task.aur.index.substatus.checking=Überprüfung auf Aktualisierungen
|
||||
arch.task.aur.index.substatus.download=Herunterladen des AUR-Index
|
||||
arch.task.aur.index.substatus.error.download=Verbindungsfehler beim Herunterladen des Indexes
|
||||
arch.task.aur.index.substatus.error.no_data=Fehler: leerer Index
|
||||
arch.task.aur.index.substatus.gen_index=Erzeugen des Index
|
||||
arch.task.checking_settings=Überprüfung der Einstellungen
|
||||
arch.task.disabled=Deaktiviert
|
||||
arch.task.disk_cache=Indexierung der Paketdaten
|
||||
arch.task.disk_cache.checking=Überprüfung des Index
|
||||
arch.task.disk_cache.indexed=Indexiert
|
||||
arch.task.disk_cache.indexing=Indexierung
|
||||
arch.task.disk_cache.reading_files=Lesen von Dateien
|
||||
arch.task.disk_cache.waiting_aur_index=Warten auf {}
|
||||
arch.task.mirrors=Spiegel aktualisieren
|
||||
arch.task.mirrors.cached=Aktualisiert
|
||||
arch.task.optimizing=Optimieren von {}
|
||||
arch.task.sync_sb.status=Aktualisieren von {}
|
||||
arch.uninstall.clean_cached.error=Es war nicht möglich, alte {} Versionen auf dem Datenträger zu entfernen
|
||||
arch.uninstall.clean_cached.substatus=Alte Versionen vom Datenträger entfernen
|
||||
arch.uninstall.error.hard_dep_in_hold=Es ist nicht möglich, {} zu deinstallieren, da eine seiner Abhängigkeiten als "InHold" markiert ist
|
||||
arch.uninstall.required_by=Die folgenden Pakete ({no}) hängen von {pkgs} ab, um richtig zu funktionieren
|
||||
arch.uninstall.required_by.warn=Sie müssen ebenfalls deinstalliert werden, um fortzufahren
|
||||
arch.uninstall.unnecessary.all=Die folgenden {} Pakete werden deinstalliert
|
||||
arch.uninstall.unnecessary.cancel=Behalten
|
||||
arch.uninstall.unnecessary.l1=Pakete erfolgreich deinstalliert!
|
||||
arch.uninstall.unnecessary.l2=Die folgenden Pakete scheinen nicht mehr notwendig zu sein
|
||||
arch.uninstall.unnecessary.proceed=Deinstallieren
|
||||
arch.uninstalling.conflict=Deinstallation von in Konflikt stehenden Paketen
|
||||
arch.uninstalling.conflict.fail=Es war nicht möglich, die in Konflikt stehenden Pakete zu deinstallieren: {}
|
||||
arch.update.disabled.tooltip=Dieses Paket kann nur über die Aktion "Schnelles System-Upgrade" upgegradet werden.
|
||||
arch.update_summary.conflict_between=Konflikt zwischen {} und {}
|
||||
arch.update_summary.to_install.dep_conflict=Konflikt zwischen den Abhängigkeiten {} und {}
|
||||
arch.update_summary.to_update.conflicts_dep=Konflikte mit der Abhängigkeit {} von {}
|
||||
arch.update_summary.to_update.dep_conflicts=Abhängigkeit {} steht im Konflikt mit {}
|
||||
arch.upgrade.caching_pkgs_data=Zwischenspeichern von Aktualisierungsdaten
|
||||
arch.upgrade.error.conflicting_files=Einige der zu aktualisierenden Pakete wollen Dateien anderer installierten Pakete überschreiben
|
||||
arch.upgrade.error.dep_breakage=Es wurden einige Probleme mit Abhängigkeitsbrüchen festgestellt
|
||||
arch.upgrade.error.dep_breakage.item=Die neue Version von {} bricht die Abhängigkeit {}, die von der installierten Version von {} benötigt wird
|
||||
arch.upgrade.error.dep_breakage.proceed=Trotzdem fortfahren
|
||||
arch.upgrade.error.dep_breakage.stop=Upgrade abbrechen
|
||||
arch.upgrade.conflicting_files.proceed=Erlauben und fortfahren
|
||||
arch.upgrade.conflicting_files.stop=Upgrade abbrechen
|
||||
arch.upgrade.fail=Upgrade des Pakets {} fehlgeschlagen
|
||||
arch.upgrade.mthreaddownload.fail=Es war nicht möglich, alle Pakete für das Upgrade herunterzuladen
|
||||
arch.upgrade.success=Paket {} erfolgreich upgegradet
|
||||
arch.upgrade.upgrade_aur_pkgs=Aktualisierung von AUR-Paketen
|
||||
arch.upgrade.upgrade_repo_pkgs=Upgraden von Paketen aus Repositories
|
||||
arch.warning.disabled={} scheint nicht installiert zu sein. Es wird nicht möglich sein, Arch / AUR Pakete zu verwalten.
|
||||
arch.warning.aur_missing_dep={} scheint nicht installiert zu sein. Es wird nicht möglich sein, AUR-Pakete zu verwalten.
|
||||
arch_repo.history.1_version=Version
|
||||
arch_repo.history.2_release=Veröffentlichung
|
||||
arch_repo.history.3_date=Datum
|
||||
aur.history.1_version=Version
|
||||
aur.history.2_release=Veröffentlichung
|
||||
aur.history.3_date=Datum
|
||||
category.orphan=verwaist
|
||||
category.out_of_date=veraltet
|
||||
gem.arch.info=Verfügbare Softwarepakete für Distributionen, die auf Arch Linux basieren
|
||||
gem.arch.label=Arch
|
||||
gem.arch.type.arch_repo.label=Arch - Repository
|
||||
gem.arch.type.aur.label=Arch - AUR
|
||||
@@ -1,318 +0,0 @@
|
||||
arch.action.rebuild_check.allow=Allow reinstallation check
|
||||
arch.action.rebuild_check.allow.desc=Allows to verify the need of reinstalling the package
|
||||
arch.action.rebuild_check.allow.status=Allowing reinstallation check
|
||||
arch.action.rebuild_check.allow.confirm=Allow reinstallation check for {}?
|
||||
arch.action.rebuild_check.ignore=Ignore reinstallation check
|
||||
arch.action.rebuild_check.ignore.desc=Do not verify if the package needs to be reinstalled on the system
|
||||
arch.action.rebuild_check.ignore.status=Ignoring reinstallation check
|
||||
arch.action.rebuild_check.ignore.confirm=Ignore reinstallation check for {}?
|
||||
arch.action.db_locked.body.l1=The system's package database is locked.
|
||||
arch.action.db_locked.body.l2=It is necessary to unlock it to continue.
|
||||
arch.action.db_locked.confirmation=Unlock and continue
|
||||
arch.action.db_locked.error=It was not possible to unlock the database.
|
||||
arch.action.db_locked.title=Database locked
|
||||
arch.action.disable_pkgbuild_edition=Unmark PKGBUILD as editable
|
||||
arch.action.disable_pkgbuild_edition.confirm=Unmark PKGBUILD of {} as editable?
|
||||
arch.action.disable_pkgbuild_edition.desc=Do not allow the package's PKGBUILD file to be edited before updating it
|
||||
arch.action.disable_pkgbuild_edition.status=Unmarking PKGBUILD as editable
|
||||
arch.action.enable_pkgbuild_edition=Mark PKGBUILD as editable
|
||||
arch.action.enable_pkgbuild_edition.confirm=Mark PKGBUILD of {} as editable?
|
||||
arch.action.enable_pkgbuild_edition.desc=Allows the package's PKGBUILD file to be edited before updating it
|
||||
arch.action.enable_pkgbuild_edition.status=Marking PKGBUILD as editable
|
||||
arch.action.reinstall=Reinstall
|
||||
arch.action.reinstall.desc=Tries to install the package again
|
||||
arch.action.reinstall.status=Reinstalling
|
||||
arch.action.reinstall.confirm=Do you want to reinstall {}?
|
||||
arch.action.reinstall.error.no_apidata=It was not possible to retrieve information of {} from AUR
|
||||
arch.aur.action.edit_pkgbuild.body=Edit the PKGBUILD file of {} before continuing?
|
||||
arch.aur.install.pgp.body=To install {} is necessary to receive the following PGP keys
|
||||
arch.aur.install.pgp.receive_fail=Could not receive PGP key {}
|
||||
arch.aur.install.pgp.sign_fail=Could not sign PGP key {}
|
||||
arch.aur.install.pgp.substatus=Receiving PGP key {}
|
||||
arch.aur.install.pgp.success=PGP keys received and signed
|
||||
arch.aur.install.pgp.title=PGP keys required
|
||||
arch.aur.install.unknown_key.receive_error=Could not receive public key {}
|
||||
arch.aur.install.unknown_key.status=Receiving public key {}
|
||||
arch.aur.install.validity_check.body=Some of the source-files needed for {} installation are not healthy.
|
||||
arch.aur.install.validity_check.proceed=Do you want to continue anyway? (not recommended)
|
||||
arch.aur.install.validity_check.title=Integrity issues {}
|
||||
arch.aur.install.verifying_pgp=Verifying PGP keys
|
||||
arch.aur.build.list_output=Checking built files
|
||||
arch.aur.sync.several_names.popup.body=The definition file (PKGBUILD) of {} configures the build of other packages
|
||||
arch.aur.sync.several_names.popup.bt_only_chosen=Build only {}
|
||||
arch.aur.sync.several_names.popup.bt_selected=Build selected too
|
||||
arch.building.package=Building package {}
|
||||
arch.can_work.not_arch_distro=Only available for ArchLinux based distributions
|
||||
arch.checking.conflicts=Checking any conflicts with {}
|
||||
arch.checking.deps=Checking {} dependencies
|
||||
arch.checking.missing_deps=Verifying missing dependencies of {}
|
||||
arch.clone=Cloning the AUR repository {}
|
||||
arch.category.remove_from_aur=Removed from AUR
|
||||
arch.config.aur=AUR packages
|
||||
arch.config.aur.tip=It allows to manage AUR packages. git must be installed.
|
||||
arch.config.aur_rebuild_detector=Check reinstallation need
|
||||
arch.config.aur_rebuild_detector.tip=It checks if packages built with old library versions require to be rebuilt. If a package needs to be rebuilt, it will be marked for update ({} must be installed)
|
||||
arch.config.aur_rebuild_detector_no_bin=Ignore binaries ({})
|
||||
arch.config.aur_rebuild_detector_no_bin.tip=If binary packages named as "package-bin" should be ignored by {} ({})
|
||||
arch.config.automatch_providers=Auto-match dependency by name
|
||||
arch.config.automatch_providers.tip=It associates automatically a package to a dependency if both names match. Otherwise all providers for a given dependency will be displayed.
|
||||
arch.config.aur_build_dir=Build directory
|
||||
arch.config.aur_build_dir.tip=It define a custom directory where the AUR packages will be built. Default: {}.
|
||||
arch.config.aur_build_only_chosen=Build only chosen
|
||||
arch.config.aur_build_only_chosen.tip=Some AUR packages have a common PKGBUILD shared with other packages and that defines build instructions for each one. This property enabled will ensure that only the chosen package will be built.
|
||||
arch.config.aur_remove_build_dir=Remove build directory
|
||||
arch.config.aur_remove_build_dir.tip=If a package's generated build directory should be removed after the operations is finished.
|
||||
arch.config.categories_exp=Categories expiration
|
||||
arch.config.categories_exp.tip=It defines the expiration time (in HOURS) of the packages categories mapping file stored in disc. Use 0 so that it is always updated during initialization.
|
||||
arch.config.clean_cache=Remove old versions
|
||||
arch.config.clean_cache.tip=Whether old versions of a package stored on disk should be removed during uninstall
|
||||
arch.config.check_dependency_breakage=Check dependency version breakage
|
||||
arch.config.check_dependency_breakage.tip=If, during the verification of upgrade requirements, specific versions of dependencies must also be checked. Example: package A depends on version 1.0 of B.
|
||||
arch.config.edit_aur_pkgbuild=Edit PKGBUILD
|
||||
arch.config.edit_aur_pkgbuild.tip=If the PKGBUILD file of an AUR package should be displayed for editing before its installation/upgrade/downgrade
|
||||
arch.config.aur_idx_exp=Index expiration
|
||||
arch.config.aur_idx_exp.tip=It defines the period (in HOURS) for the AUR index stored in disc to be considered up to date during the initialization process. Use 0 so that it is always updated.
|
||||
arch.config.mirrors_sort_limit=Mirrors sort limit
|
||||
arch.config.mirrors_sort_limit.tip=Defines the maximum number of mirrors that will be used for speed sorting. Use 0 for no limit or leave it blank to disable sorting.
|
||||
arch.config.optimize=Optimize
|
||||
arch.config.optimize.tip=Optimized settings will be used in order to make the packages installation, upgrading and downgrading faster, otherwise the system settings will be used
|
||||
arch.config.pacman_mthread_download=Multi-threaded download (repositories)
|
||||
arch.config.pacman_mthread_download.tip=Whether the repository packages should be downloaded with a tool that works with threads (it may be faster). pacman-mirrors must be installed.
|
||||
arch.config.prefer_repository_provider=Prefer repository dependencies
|
||||
arch.config.prefer_repository_provider.tip=Automatically picks the single package from the repositories among several external ({}) available as the provider for a given dependency
|
||||
arch.config.refresh_mirrors=Refresh mirrors on startup
|
||||
arch.config.refresh_mirrors.tip=Refresh the package mirrors once a day on startup
|
||||
arch.config.repos=Repositories packages
|
||||
arch.config.repos.tip=It allows to manage packages from the repositories set
|
||||
arch.config.suggest_optdep_uninstall=Uninstall optional dependencies
|
||||
arch.config.suggest_optdep_uninstall.tip=If the optional dependencies associated with uninstalled packages should be suggested for uninstallation. Only the optional dependencies that are not dependencies of other packages will be suggested.
|
||||
arch.config.suggest_unneeded_uninstall=Uninstall unneeded dependencies
|
||||
arch.config.suggest_unneeded_uninstall.tip=If the dependencies apparently no longer necessary associated with the uninstalled packages should be suggested for uninstallation. When this property is enabled it automatically disables the property {}.
|
||||
arch.config.suggest_optdep_select=Download optional dependencies
|
||||
arch.config.suggest_optdep_select.tip=Selects all or no optional dependencies when installing packages
|
||||
arch.config.suggestions_exp=Suggestions expiration
|
||||
arch.config.suggestions_exp.tip=It defines the period (in hours) in which the suggestions stored in disc will be considered up to date. Use 0 if you always want to update them.
|
||||
arch.config.sync_dbs=Synchronize packages databases
|
||||
arch.config.sync_dbs.tip=Synchronizes the package databases once a day before the first package installation, upgrade or downgrade. This option helps to prevent errors during these operations.
|
||||
arch.config.sync_dbs_start.tip=Synchronizes the package databases during the initialization once a day
|
||||
arch.custom_action.clean_cache=Clean cache
|
||||
arch.custom_action.clean_cache.desc=Removes all the downloade package files from the disk cache
|
||||
arch.custom_action.clean_cache.fail=An error occurred while cleaning the cache
|
||||
arch.custom_action.clean_cache.msg1=The cache is a system directory where files of old package versions are stored
|
||||
arch.custom_action.clean_cache.msg2=Cleaning it frees storage space without harming your system
|
||||
arch.custom_action.clean_cache.msg3=It also helps when there are downloaded packages with integrity issues blocking an action
|
||||
arch.custom_action.clean_cache.no_dir=The cache directory {} does not exist
|
||||
arch.custom_action.clean_cache.status=Cleaning cache
|
||||
arch.custom_action.clean_cache.success=Cache successfully cleaned!
|
||||
arch.custom_action.refresh_dbs=Synchronize package databases
|
||||
arch.custom_action.refresh_dbs.desc=Synchronizes the available packages on the repositories
|
||||
arch.custom_action.refresh_dbs.failed=It was not possible to synchronize the package databases
|
||||
arch.custom_action.refresh_mirrors=Refresh mirrors
|
||||
arch.custom_action.refresh_mirrors.desc=Allows to choose the repository mirrors and sort them by the fastest
|
||||
arch.custom_action.refresh_mirrors.failed=It was not possible to refresh the mirrors
|
||||
arch.custom_action.refresh_mirrors.location.all=All
|
||||
arch.custom_action.refresh_mirrors.location.all.tip=If this option is checked, the others will be ignored.
|
||||
arch.custom_action.refresh_mirrors.select_label=Check the desired locations
|
||||
arch.custom_action.refresh_mirrors.status.sorting=Sorting mirrors by speed
|
||||
arch.custom_action.refresh_mirrors.status.updating=Updating mirrors
|
||||
arch.custom_action.setup_snapd=Check Snaps support
|
||||
arch.custom_action.setup_snapd.desc=Checks if the Snaps support are properly enabled on the system
|
||||
snap.custom_action.setup_snapd.missing_link=Create the link {} for {}
|
||||
arch.custom_action.setup_snapd.status=Checking Snaps support
|
||||
snap.custom_action.setup_snapd.ready=Ready!
|
||||
snap.custom_action.setup_snapd.ready.body=The system is ready to work with Snaps!
|
||||
snap.custom_action.setup_snapd.required_actions=Actions required for Snaps to work correctly
|
||||
snap.custom_action.setup_snapd.service_disabled=Enable the service {}
|
||||
snap.custom_action.setup_snapd.service_inactive=Start the service {}
|
||||
arch.custom_action.upgrade_system=Quick system upgrade
|
||||
arch.custom_action.upgrade_system.desc=Tries to upgrade the system with a single pacman call
|
||||
arch.custom_action.upgrade_system.no_updates=There are no updates available
|
||||
arch.custom_action.upgrade_system.pkgs=The packages below will be upgraded
|
||||
arch.custom_action.upgrade_system.status=Upgrading system
|
||||
arch.custom_action.upgrade_system.substatus=Upgrading packages
|
||||
arch.custom_action.upgrade_system.success.line1=System successfully upgraded!
|
||||
arch.custom_action.upgrade_system.success.line2=Some changes may require a system restart to take effect.
|
||||
arch.custom_action.upgrade_system.success.line3=Restart now?
|
||||
arch.dialog.providers.line1=There are multiple providers for some dependencies
|
||||
arch.dialog.providers.line2=Select those you want
|
||||
arch.downgrade.error=Error
|
||||
arch.downgrade.impossible=It is not possible to downgrade {}
|
||||
arch.downgrade.install_older=Installing older version
|
||||
arch.downgrade.reading_commits=Reading the repository commits
|
||||
arch.downgrade.repo_pkg.no_versions=No old version found on disk
|
||||
arch.downgrade.searching_stored=Looking for old versions on disk
|
||||
arch.downgrade.version_found=Current package version found
|
||||
arch.aur.error.missing_root_dep={dep} is not installed and is required for installing {aur} packages as the {root} user
|
||||
arch.aur.error.add_builder_user=It was not possible to create the user {user} for building {aur} packages
|
||||
arch.info.00_pkg_build=pkgbuild
|
||||
arch.info.00_url=URL
|
||||
arch.info.01_id=id
|
||||
arch.info.02_name=name
|
||||
arch.info.03_description=description
|
||||
arch.info.03_version=version
|
||||
arch.info.04_exec=Executable
|
||||
arch.info.04_orphan=orphan
|
||||
arch.info.04_orphan.true=yes
|
||||
arch.info.04_orphan.false=no
|
||||
arch.info.04_out_of_date=out of date
|
||||
arch.info.04_out_of_date.true=yes
|
||||
arch.info.04_out_of_date.false=no
|
||||
arch.info.04_popularity=popularity
|
||||
arch.info.05_votes=votes
|
||||
arch.info.06_package_base=package base
|
||||
arch.info.07_maintainer=maintainer
|
||||
arch.info.08_first_submitted=first submitted
|
||||
arch.info.09_last_modified=last modified
|
||||
arch.info.10_url=url download
|
||||
arch.info.11_pkg_build_url=url pkgbuild
|
||||
arch.info.12_makedepends=compilation dependencies
|
||||
arch.info.13_dependson=installation dependencies
|
||||
arch.info.13_pkg_build=pkgbuild
|
||||
arch.info.14_installed_files=Installed files
|
||||
arch.info.14_optdepends=optional dependencies
|
||||
arch.info.15_checkdepends=checking dependencies
|
||||
arch.info.arch=arch
|
||||
arch.info.arch.any=any
|
||||
arch.info.architecture=architecture
|
||||
arch.info.architecture.any=any
|
||||
arch.info.build date=build date
|
||||
arch.info.conflicts with=conflicts with
|
||||
arch.info.depends=depends
|
||||
arch.info.depends on=depends on
|
||||
arch.info.description=description
|
||||
arch.info.download size=Download size
|
||||
arch.info.install date=install date
|
||||
arch.info.install reason=install reason
|
||||
arch.info.install reason.explicitly installed=explicitly installed
|
||||
arch.info.install reason.installed as a dependency for another package=dependency of another package
|
||||
arch.info.install script=install script
|
||||
arch.info.install script.no=no
|
||||
arch.info.installed files=installed files
|
||||
arch.info.installed size=installed size
|
||||
arch.info.last_modified=last modified
|
||||
arch.info.license=license
|
||||
arch.info.licenses=licenses
|
||||
arch.info.licenses.custom=custom
|
||||
arch.info.name=name
|
||||
arch.info.optdepends=optional dependencies
|
||||
arch.info.optional deps=optional dependencies
|
||||
arch.info.optional for=optional for
|
||||
arch.info.options=options
|
||||
arch.info.packager=packager
|
||||
arch.info.packager.unknown packager=unknown
|
||||
arch.info.pkgdesc=description
|
||||
arch.info.pkgname=name
|
||||
arch.info.pkgrel=release
|
||||
arch.info.pkgver=version
|
||||
arch.info.provides=provides
|
||||
arch.info.replaces=replaces
|
||||
arch.info.required by=required by
|
||||
arch.info.source=source
|
||||
arch.info.url=url
|
||||
arch.info.validated by=validated by
|
||||
arch.info.validated by.signature=signature
|
||||
arch.info.validpgpkeys=valid PGP keys
|
||||
arch.info.version=version
|
||||
arch.install.aur.root_error.body=It is not allowed to install, upgrade or downgrade a package as the root user
|
||||
arch.install.aur.root_error.title=Action not allowed
|
||||
arch.install.aur.unknown_key.body=To continue {} installation is necessary to trust the following public key {}
|
||||
arch.install.aur.unknown_key.title=Public key required
|
||||
arch.install.conflict.popup.body=The applications {} are in conflict. You must uninstall one to install the other. Continue?
|
||||
arch.install.conflict.popup.title=Conflict detected
|
||||
arch.install.dep_not_found.body.l1=Required dependency {dep}{source} was not found on the repositories nor AUR.
|
||||
arch.install.dep_not_found.body.l2=It might be a package database synchronization problem.
|
||||
arch.install.dep_not_found.body.l3=Operation cancelled.
|
||||
arch.install.dep_not_found.title=Dependency not found
|
||||
arch.install.dependency.install=Installing package dependency {}
|
||||
arch.install.dependency.install.error=Could not install the dependent packages: {}. Installation of {} aborted.
|
||||
arch.install.error.conflicting_files=The package {} wants to overwrite files from other installed packages
|
||||
arch.install.error.conflicting_files.proceed=Allow
|
||||
arch.install.error.conflicting_files.stop=Cancel installation
|
||||
arch.install.optdep.error=Could not install the optional packages: {}
|
||||
arch.install.optdeps.request.body=Check the optional associated packages below that you want to install
|
||||
arch.install.optdeps.request.success={pkg} was successfully installed!
|
||||
arch.install.optdeps.request.title=Optional dependencies
|
||||
arch.installing.package=Installing {} package
|
||||
arch.checking_unnecessary_deps=Checking if there are packages no longer needed
|
||||
arch.makepkg.optimizing=Optimizing the compilation
|
||||
arch.missing_deps.body=The following dependencies ({deps}) will be installed
|
||||
arch.missing_deps.title=Missing dependencies
|
||||
arch.missing_deps_found=Missing dependencies for {}
|
||||
arch.mthread_downloaded.error.cache_dir=It was not possible to create the cache directory {}
|
||||
arch.mthread_downloaded.error.cancelled=Operation cancelled
|
||||
arch.optdeps.checking=Checking {} optional dependencies
|
||||
arch.package.requires_rebuild=It needs to be reinstalled
|
||||
arch.providers=providers
|
||||
arch.substatus.conflicts=Checking for conflicts
|
||||
arch.substatus.disk_space=Checking available disk space
|
||||
arch.substatus.integrity=Checking packages integrity
|
||||
arch.substatus.keyring=Checking keyring
|
||||
arch.substatus.loading_files=Loading package files
|
||||
arch.substatus.pre_hooks=Running pre-transaction hooks
|
||||
arch.substatus.retrieve_pkgs=Retrieving packages
|
||||
arch.sync.dep_breakage.reason={} requires {}
|
||||
arch.sync_databases.substatus=Synchronizing package databases
|
||||
arch.sync_databases.substatus.error=It was not possible to synchronize the package database
|
||||
arch.sync_databases.substatus.synchronized=Synchronized
|
||||
arch.task.aur.index.status=Generating local AUR index
|
||||
arch.task.aur.index.substatus.checking=Checking for updates
|
||||
arch.task.aur.index.substatus.download=Downloading the AUR index
|
||||
arch.task.aur.index.substatus.error.download=Connection error while downloading the index
|
||||
arch.task.aur.index.substatus.error.no_data=Error: empty index
|
||||
arch.task.aur.index.substatus.gen_index=Generating index
|
||||
arch.task.checking_settings=Checking settings
|
||||
arch.task.disabled=Disabled
|
||||
arch.task.disk_cache=Indexing packages data
|
||||
arch.task.disk_cache.checking=Checking index
|
||||
arch.task.disk_cache.indexed=Indexed
|
||||
arch.task.disk_cache.indexing=Indexing
|
||||
arch.task.disk_cache.reading_files=Reading files
|
||||
arch.task.disk_cache.waiting_aur_index=Waiting {}
|
||||
arch.task.mirrors=Refreshing mirrors
|
||||
arch.task.mirrors.cached=Refreshed
|
||||
arch.task.optimizing=Optimizing {}
|
||||
arch.task.sync_sb.status=Updating {}
|
||||
arch.uninstall.clean_cached.error=It was not possible to remove old {} versions found on disk
|
||||
arch.uninstall.clean_cached.substatus=Removing old versions from disk
|
||||
arch.uninstall.error.hard_dep_in_hold=It is not possible to uninstall {} because one of its dependencies is marked as "InHold"
|
||||
arch.uninstall.required_by=The packages ({no}) below depend on {pkgs} to work properly
|
||||
arch.uninstall.required_by.warn=It is necessary to uninstall them as well to proceed
|
||||
arch.uninstall.unnecessary.all=The following {} packages will be uninstalled
|
||||
arch.uninstall.unnecessary.cancel=Keep
|
||||
arch.uninstall.unnecessary.l1=Packages successfully uninstalled!
|
||||
arch.uninstall.unnecessary.l2=The packages below seem to be no longer necessary
|
||||
arch.uninstall.unnecessary.proceed=Uninstall
|
||||
arch.uninstalling.conflict=Uninstalling conflicting packages
|
||||
arch.uninstalling.conflict.fail=It was not possible to uninstall the conflicting packages: {}
|
||||
arch.update.disabled.tooltip=This package can oly be upgrade through the action "Quick system upgrade"
|
||||
arch.update_summary.conflict_between=Conflict between {} and {}
|
||||
arch.update_summary.to_install.dep_conflict=Conflict between the dependencies {} and {}
|
||||
arch.update_summary.to_update.conflicts_dep=Conflicts with the dependency {} of {}
|
||||
arch.update_summary.to_update.dep_conflicts=Dependency {} conflicts with {}
|
||||
arch.upgrade.caching_pkgs_data=Caching updates data
|
||||
arch.upgrade.error.conflicting_files=Some of the packages being upgraded want to overwrite files of another installed packages
|
||||
arch.upgrade.error.dep_breakage=Some dependency breakage issues have been detected
|
||||
arch.upgrade.error.dep_breakage.item=The new version of {} breaks the dependency {} required by the installed version of {}
|
||||
arch.upgrade.error.dep_breakage.proceed=Proceed anyway
|
||||
arch.upgrade.error.dep_breakage.stop=Cancel upgrade
|
||||
arch.upgrade.conflicting_files.proceed=Allow and continue
|
||||
arch.upgrade.conflicting_files.stop=Cancel upgrading
|
||||
arch.upgrade.fail=Package {} upgrade failed
|
||||
arch.upgrade.mthreaddownload.fail=It was not possible to download all packages for upgrading
|
||||
arch.upgrade.success=Package {} successfully upgraded
|
||||
arch.upgrade.upgrade_aur_pkgs=Upgrading AUR packages
|
||||
arch.upgrade.upgrade_repo_pkgs=Upgrading packages from repositories
|
||||
arch.warning.disabled={} seems not to be installed. It will not be possible to manage Arch / AUR packages.
|
||||
arch.warning.aur_missing_dep={} seems not to be installed. It will not be possible to manage AUR packages.
|
||||
arch_repo.history.1_version=version
|
||||
arch_repo.history.2_release=release
|
||||
arch_repo.history.3_date=date
|
||||
aur.history.1_version=version
|
||||
aur.history.2_release=release
|
||||
aur.history.3_date=date
|
||||
category.orphan=orphan
|
||||
category.out_of_date=out of date
|
||||
gem.arch.info=Software packages available for distributions based on Arch Linux
|
||||
gem.arch.label=Arch
|
||||
gem.arch.type.arch_repo.label=Arch - Repository
|
||||
gem.arch.type.aur.label=Arch - AUR
|
||||
@@ -1,316 +0,0 @@
|
||||
arch.action.rebuild_check.allow=Permitir verificación de reinstalación
|
||||
arch.action.rebuild_check.allow.desc=Permite verificar la necesidad de reinstalar el paquete
|
||||
arch.action.rebuild_check.allow.status=Permitindo verificación de reinstalación
|
||||
arch.action.rebuild_check.allow.confirm=¿ Permitir verificación de reinstalación para {} ?
|
||||
arch.action.rebuild_check.ignore=Ignorar verificación de reinstalación
|
||||
arch.action.rebuild_check.ignore.desc=No verificar si el paquete necesita ser reinstalado en el sistema
|
||||
arch.action.rebuild_check.ignore.status=Ignorando verificación de reinstalación
|
||||
arch.action.rebuild_check.ignore.confirm=¿ Ignorar verificación de reinstalación para {} ?
|
||||
arch.action.db_locked.body.l1=La base de datos de paquetes del sistema está bloqueada.
|
||||
arch.action.db_locked.body.l2=Es necesario desbloquearla para continuar.
|
||||
arch.action.db_locked.confirmation=Desbloquear y continuar
|
||||
arch.action.db_locked.error=No fue posible desbloquear la base de datos.
|
||||
arch.action.db_locked.title=Base de dados bloqueada
|
||||
arch.action.disable_pkgbuild_edition=Desmarcar PKGBUILD como editable
|
||||
arch.action.disable_pkgbuild_edition.confirm=Desmarcar PKGBUILD de {} como editable ?
|
||||
arch.action.disable_pkgbuild_edition.desc=No permita que se edite el archivo PKGBUILD del paquete antes de actualizarlo
|
||||
arch.action.disable_pkgbuild_edition.status=Desmarcando PKGBUILD como editable
|
||||
arch.action.enable_pkgbuild_edition=Marcar PKGBUILD como editable
|
||||
arch.action.enable_pkgbuild_edition.confirm=Marcar PKGBUILD de {} como editable ?
|
||||
arch.action.enable_pkgbuild_edition.desc=Permite editar el archivo PKGBUILD del paquete antes de actualizarlo
|
||||
arch.action.enable_pkgbuild_edition.status=Marcando PKGBUILD como editable
|
||||
arch.action.reinstall=Reinstalar
|
||||
arch.action.reinstall.desc=Intenta instalar el paquete nuevamente
|
||||
arch.action.reinstall.status=Reinstalando
|
||||
arch.action.reinstall.confirm=Desea reinstalar {} ?
|
||||
arch.action.reinstall.error.no_apidata=No fue posible recuperar información de {} del AUR
|
||||
arch.aur.action.edit_pkgbuild.body=Editar el archivo PKGBUILD de {} antes de continuar ?
|
||||
arch.aur.install.pgp.body=Para instalar {} es necesario recibir las siguientes claves PGP
|
||||
arch.aur.install.pgp.receive_fail=Could not receive PGP key {}
|
||||
arch.aur.install.pgp.sign_fail=No fue posible recibir la clave PGP {}
|
||||
arch.aur.install.pgp.substatus=Recibiendo clave PGP {}
|
||||
arch.aur.install.pgp.success=Claves PGP recibidas y firmadas
|
||||
arch.aur.install.pgp.title=Claves PGP necesarias
|
||||
arch.aur.install.unknown_key.receive_error=No fue posible recibir la clave pública {}
|
||||
arch.aur.install.unknown_key.status=Recibiendo la clave pública {}
|
||||
arch.aur.install.validity_check.body=Algunos de los archivos fuente necesarios para la instalación de {} no están en buen estado.
|
||||
arch.aur.install.validity_check.proceed=¿Desea continuar de todos modos? ( no recomendado )
|
||||
arch.aur.install.validity_check.title=Problemas de integridad {}
|
||||
arch.aur.install.verifying_pgp=Verificando claves PGP
|
||||
arch.aur.build.list_output=Checking built files
|
||||
arch.aur.sync.several_names.popup.body=El archivo de definición (PKGBUILD) de {} configura la compilación de otros paquetes
|
||||
arch.aur.sync.several_names.popup.bt_only_chosen=Compilar sólo {}
|
||||
arch.aur.sync.several_names.popup.bt_selected=Compilar seleccionados también
|
||||
arch.building.package=Construyendo el paquete {}
|
||||
arch.can_work.not_arch_distro=Solo disponible para distribuciones basadas en ArchLinux
|
||||
arch.checking.conflicts=Verificando se hay conflictos con {}
|
||||
arch.checking.deps=Verificando las dependencias de {}
|
||||
arch.checking.missing_deps=Verificando las dependencias faltantes de {}
|
||||
arch.clone=Clonando el repositorio {} de AUR
|
||||
arch.category.remove_from_aur=Eliminado del AUR
|
||||
arch.config.aur=Paquetes de AUR
|
||||
arch.config.aur.tip=Permite gestionar paquetes del AUR. git debe estar instalado.
|
||||
arch.config.aur_rebuild_detector=Verificar necesidad de reinstalación
|
||||
arch.config.aur_rebuild_detector.tip=Verifica si los paquetes creados con versiones antiguas de bibliotecas necesitan ser reconstruidos. Si es necesario reconstruir un paquete, el será marcado para actualización ({} debe estar instalado)
|
||||
arch.config.aur_rebuild_detector_no_bin=Ignorar binarios ({})
|
||||
arch.config.aur_rebuild_detector_no_bin.tip=Si los paquetes binarios nombrados como "paquete-bin" deben ser ignorados por {} ({})
|
||||
arch.config.automatch_providers=Auto-corresponder dependencia por nombre
|
||||
arch.config.automatch_providers.tip=Asocia automáticamente un paquete a una dependencia si ambos nombres coinciden. De lo contrario, se mostrarán todos los proveedores para la dependencia.
|
||||
arch.config.aur_build_dir=Directorio de compilación
|
||||
arch.config.aur_build_dir.tip=Define un directorio personalizado donde se construirán los paquetes AUR. Defecto: {}.
|
||||
arch.config.aur_build_only_chosen=Compilar solo elegido
|
||||
arch.config.aur_build_only_chosen.tip=Algunos paquetes AUR tienen un PKGBUILD común compartido con otros paquetes y que define las instrucciones de construcción para cada uno. Esta propiedad habilitada garantizará que solo se compile el paquete elegido.
|
||||
arch.config.aur_remove_build_dir=Eliminar directorio de compilación
|
||||
arch.config.aur_remove_build_dir.tip=Si el directorio de compilación generado para un paquete debe ser eliminado una vez finalizada la operación.
|
||||
arch.config.categories_exp=Expiración de categorías
|
||||
arch.config.categories_exp.tip=Define el tiempo de vencimiento (en HORAS) del archivo de mapeo de categorías de paquetes almacenado en el disco. Utilice 0 para que siempre se actualice durante la inicialización.
|
||||
arch.config.clean_cache=Eliminar versiones antiguas
|
||||
arch.config.clean_cache.tip=Si las versiones antiguas de un paquete almacenado en el disco deben ser eliminadas durante la desinstalación
|
||||
arch.config.check_dependency_breakage=Verificar rotura de versión de dependencia
|
||||
arch.config.check_dependency_breakage.tip=Si, durante la verificación de los requisitos de actualización, también se deben verificar versiones específicas de las dependencias. Ejemplo: el paquete A depende de la versión 1.0 de B.
|
||||
arch.config.edit_aur_pkgbuild=Editar PKGBUILD
|
||||
arch.config.edit_aur_pkgbuild.tip=Si el archivo PKGBUILD de un paquete AUR debe ser exhibido para edición antes de su instalación/actualización/degradación
|
||||
arch.config.aur_idx_exp=Expiración del índice
|
||||
arch.config.aur_idx_exp.tip=Define el período (en HORAS) en que el índice de AUR almacenado en el disco es considerado actualizado durante el proceso de inicialización. Utilice 0 para que sea siempre actualizado.
|
||||
arch.config.mirrors_sort_limit=Límite de ordenación de espejos
|
||||
arch.config.mirrors_sort_limit.tip=Define el número máximo de espejos que se utilizarán para la ordenación por velocidad. Use 0 para no limitar o déjelo en blanco para deshabilitar la clasificación.
|
||||
arch.config.optimize=Optimizar
|
||||
arch.config.optimize.tip=Se usará la configuración optimizada para que la instalación, actualización y reversión de los paquetes sean más rápidas, de lo contrario se usará la configuración del sistema
|
||||
arch.config.pacman_mthread_download=Descarga segmentada (repositorios)
|
||||
arch.config.pacman_mthread_download.tip=Si los paquetes de los repositorios deben descargarse con una herramienta que usa segmentación/threads (puede ser más rápido). pacman-mirrors necesita estar instalado.
|
||||
arch.config.prefer_repository_provider=Preferir dependencias de repositorio
|
||||
arch.config.prefer_repository_provider.tip=Elige automáticamente el paquete unico de los repositorios entre varios externos ({}) disponibles como el proveedor para una dependencia
|
||||
arch.config.refresh_mirrors=Actualizar espejos al iniciar
|
||||
arch.config.refresh_mirrors.tip=Actualiza los espejos de paquetes una vez al día al iniciar
|
||||
arch.config.repos=Paquetes de repositorios
|
||||
arch.config.repos.tip=Permite gestionar paquetes de los repositorios configurados
|
||||
arch.config.suggest_optdep_uninstall=Desinstalar dependencias opcionales
|
||||
arch.config.suggest_optdep_uninstall.tip=Si las dependencias opcionales asociadas con los paquetes desinstalados deben se sugeridas para desinstalación. Solo se sugerirán las dependencias opcionales que no sean dependencias de otros paquetes.
|
||||
arch.config.suggest_unneeded_uninstall=Desinstalar las dependencias innecesarias
|
||||
arch.config.suggest_unneeded_uninstall.tip=Si las dependencias aparentemente ya no necesarias asociadas con los paquetes desinstalados deben ser sugeridas para desinstalación. Cuando esta propiedad está habilitada, automáticamente deshabilita la propiedad {}.
|
||||
arch.config.suggestions_exp=Expiración de sugerencias
|
||||
arch.config.suggestions_exp.tip=Define el período (en horas) en el que la sugerencias almacenadas en disco seran consideradas actualizadas. Use 0 si desea siempre actualizarlas.
|
||||
arch.config.sync_dbs=Sincronizar las bases de paquetes
|
||||
arch.config.sync_dbs.tip=Sincroniza las bases de paquetes una vez al día antes de la primera instalación, actualización o reversión de paquete. Esta opción ayuda a prevenir errores durante estas operaciones.
|
||||
arch.config.sync_dbs_start.tip=Sincroniza las bases de paquetes durante la inicialización una vez al día
|
||||
arch.custom_action.clean_cache=Limpiar cache
|
||||
arch.custom_action.clean_cache.desc=Elimina todos los archivos de paquetes descargados en el caché de disco
|
||||
arch.custom_action.clean_cache.fail=Se produjo un error al limpiar el caché
|
||||
arch.custom_action.clean_cache.msg1=El caché es un directorio del sistema donde se almacenan los archivos de versiones anteriores de paquetes
|
||||
arch.custom_action.clean_cache.msg2=Limpiarlo libera espacio de almacenamiento sin dañar su sistema
|
||||
arch.custom_action.clean_cache.msg3=También ayuda cuando hay paquetes descargados con problemas de integridad que bloquean una acción
|
||||
arch.custom_action.clean_cache.no_dir=El directorio de cache {} no existe
|
||||
arch.custom_action.clean_cache.status=Limpiando cache
|
||||
arch.custom_action.clean_cache.success=Caché limpiado con éxito!
|
||||
arch.custom_action.refresh_dbs=Sincronizar bases de paquetes
|
||||
arch.custom_action.refresh_dbs.desc=Sincroniza los paquetes disponibles en los repositorios
|
||||
arch.custom_action.refresh_dbs.failed=No fue posible sincronizar las bases de paquete
|
||||
arch.custom_action.refresh_mirrors=Actualizar espejos
|
||||
arch.custom_action.refresh_mirrors.desc=Permite elegir los espejos de repositorios y ordenarlos por velocidad
|
||||
arch.custom_action.refresh_mirrors.failed=No fue posible actualizar los espejos
|
||||
arch.custom_action.refresh_mirrors.location.all=Todas
|
||||
arch.custom_action.refresh_mirrors.location.all.tip=Si esta opción está marcada, las demás serán ignoradas.
|
||||
arch.custom_action.refresh_mirrors.select_label=Marcar las ubicaciones deseadas
|
||||
arch.custom_action.refresh_mirrors.status.sorting=Ordenando los espejos por velocidad
|
||||
arch.custom_action.refresh_mirrors.status.updating=Actualizando espejos
|
||||
arch.custom_action.setup_snapd=Verificar soporte de Snaps
|
||||
arch.custom_action.setup_snapd.desc=Verifica si la compatibilidad con Snaps está habilitada correctamente en el sistema
|
||||
snap.custom_action.setup_snapd.missing_link=Crear el link {} para {}
|
||||
arch.custom_action.setup_snapd.status=Verificando soporte de Snaps
|
||||
snap.custom_action.setup_snapd.ready=¡Listo!
|
||||
snap.custom_action.setup_snapd.ready.body=¡El sistema está listo para trabajar con Snaps!
|
||||
snap.custom_action.setup_snapd.required_actions=Acciones necesarias para que los Snaps funcionen correctamente
|
||||
snap.custom_action.setup_snapd.service_disabled=Habilitar el servicio {}
|
||||
snap.custom_action.setup_snapd.service_inactive=Iniciar el servicio {}
|
||||
arch.custom_action.upgrade_system=Actualización rápida de sistema
|
||||
arch.custom_action.upgrade_system.desc=Intenta actualizar el sistema con una sola llamada a pacman
|
||||
arch.custom_action.upgrade_system.no_updates=No hay actualizaciones disponibles
|
||||
arch.custom_action.upgrade_system.pkgs=Los paquetes abajo serán actualizados
|
||||
arch.custom_action.upgrade_system.status=Actualizando sistema
|
||||
arch.custom_action.upgrade_system.substatus=Actualizando paquetes
|
||||
arch.custom_action.upgrade_system.success.line1=¡Sistema actualizado con éxito!
|
||||
arch.custom_action.upgrade_system.success.line2=Algunos cambios pueden requerir un reinicio del sistema para que surta efecto.
|
||||
arch.custom_action.upgrade_system.success.line3=¿Reiniciar ahora?
|
||||
arch.dialog.providers.line1=Hay múltiples proveedores para algunas dependencias
|
||||
arch.dialog.providers.line2=Seleccione las que desea
|
||||
arch.downgrade.error=Error
|
||||
arch.downgrade.impossible=No es posible revertir la versión de {}
|
||||
arch.downgrade.install_older=Instalando versión anterior
|
||||
arch.downgrade.reading_commits=Leyendo los commits del repositorio
|
||||
arch.downgrade.repo_pkg.no_versions=No se encontró una versión anterior en el disco
|
||||
arch.downgrade.searching_stored=Buscando versiones antiguas en el disco
|
||||
arch.downgrade.version_found=Version actual del paquete encontrada
|
||||
arch.aur.error.missing_root_dep={dep} no está instalado y es necesario para la instalación de paquetes del {aur} como el usuario {root}
|
||||
arch.aur.error.add_builder_user=No fue posible crear el usuario {user} para construir paquetes del {aur}
|
||||
arch.info.00_pkg_build=pkgbuild
|
||||
arch.info.00_url=URL
|
||||
arch.info.01_id=id
|
||||
arch.info.02_name=nombre
|
||||
arch.info.03_description=descripción
|
||||
arch.info.03_version=versión
|
||||
arch.info.04_exec=Ejecutable
|
||||
arch.info.04_orphan=huérfano
|
||||
arch.info.04_orphan.true=si
|
||||
arch.info.04_orphan.false=no
|
||||
arch.info.04_out_of_date=desactualizado
|
||||
arch.info.04_out_of_date.true=si
|
||||
arch.info.04_out_of_date.false=no
|
||||
arch.info.04_popularity=popularidad
|
||||
arch.info.05_votes=votos
|
||||
arch.info.06_package_base=paquete base
|
||||
arch.info.07_maintainer=mantenedor
|
||||
arch.info.08_first_submitted=primero envio
|
||||
arch.info.09_last_modified=última modificación
|
||||
arch.info.10_url=url para descarga
|
||||
arch.info.11_pkg_build_url=url pkgbuild
|
||||
arch.info.12_makedepends=dependencias para compilacion
|
||||
arch.info.13_dependson=dependencias para instalación
|
||||
arch.info.13_pkg_build=pkgbuild
|
||||
arch.info.14_installed_files=Archivos instalados
|
||||
arch.info.14_optdepends=dependencias opcionales
|
||||
arch.info.15_checkdepends=dependencias para verificación
|
||||
arch.info.arch=arquitectura
|
||||
arch.info.arch.any=cualquier
|
||||
arch.info.architecture=arquitectura
|
||||
arch.info.architecture.any=cualquier
|
||||
arch.info.build date=fecha de construcción
|
||||
arch.info.conflicts with=conflicta
|
||||
arch.info.depends=depende
|
||||
arch.info.depends on=depende de
|
||||
arch.info.description=descripción
|
||||
arch.info.download size=Tamaño de descarga
|
||||
arch.info.install date=fecha de instalación
|
||||
arch.info.install reason=razón da instalación
|
||||
arch.info.install reason.explicitly installed=instalado explícitamente
|
||||
arch.info.install reason.installed as a dependency for another package=dependencia de otro paquete
|
||||
arch.info.install script=script de instalación
|
||||
arch.info.install script.no=ninguno
|
||||
arch.info.installed files=archivos instalados
|
||||
arch.info.installed size=tamaño da instalación
|
||||
arch.info.last_modified=última modificación
|
||||
arch.info.license=licencia
|
||||
arch.info.licenses=licencias
|
||||
arch.info.licenses.custom=personalizada
|
||||
arch.info.name=nombre
|
||||
arch.info.optdepends=dependencias opcionales
|
||||
arch.info.optional deps=dependencias opcionales
|
||||
arch.info.optional for=opcional para
|
||||
arch.info.options=opciones
|
||||
arch.info.packager=empaquetador
|
||||
arch.info.packager.unknown packager=desconocido
|
||||
arch.info.pkgdesc=descripción
|
||||
arch.info.pkgname=nombre
|
||||
arch.info.pkgrel=lanzamiento
|
||||
arch.info.pkgver=versión
|
||||
arch.info.provides=provee
|
||||
arch.info.replaces=reemplaza
|
||||
arch.info.required by=requerido por
|
||||
arch.info.source=origen
|
||||
arch.info.url=url
|
||||
arch.info.validated by=validado por
|
||||
arch.info.validated by.signature=firma
|
||||
arch.info.validpgpkeys=llaves PGP válidas
|
||||
arch.info.version=versión
|
||||
arch.install.aur.root_error.body=No es permitido instalar, actualizar o revertir la versión de un paquete como usuario root
|
||||
arch.install.aur.root_error.title=Acción no permitida
|
||||
arch.install.aur.unknown_key.body=Para continuar la instalación de {} es necesario confiar en la siguiente clave pública {}
|
||||
arch.install.aur.unknown_key.title=Clave pública necesaria
|
||||
arch.install.conflict.popup.body=Los aplicativos {} estan en conflicto. Debe desinstalar uno para instalar el otro. ¿Continuar?
|
||||
arch.install.conflict.popup.title=Conflicto detectado
|
||||
arch.install.dep_not_found.body.l1=No se encontró la dependencia requerida {dep}{source} en AUR ni en los repositorios.
|
||||
arch.install.dep_not_found.body.l2=Puede ser un problema de sincronización de la base de paquetes.
|
||||
arch.install.dep_not_found.body.l3=Operación cancelada.
|
||||
arch.install.dep_not_found.title=Dependencia no encontrada
|
||||
arch.install.dependency.install=Instalando el paquete dependiente {}
|
||||
arch.install.dependency.install.error=No se pudo instalar los paquetes dependientes: {}. Instalación de {} abortada.
|
||||
arch.install.error.conflicting_files=El paquete {} quiere sobrescribir archivos de otros paquetes instalados
|
||||
arch.install.error.conflicting_files.proceed=Permitir
|
||||
arch.install.error.conflicting_files.stop=Cancelar instalación
|
||||
arch.install.optdep.error=No se pudo instalar los paquetes opcionales: {}
|
||||
arch.install.optdeps.request.body=Marque los paquetes opcionales asociados abajo que desea instalar
|
||||
arch.install.optdeps.request.success=¡{pkg} se instaló correctamente!
|
||||
arch.install.optdeps.request.title=Dependencias opcionales
|
||||
arch.installing.package=Instalando el paquete {}
|
||||
arch.checking_unnecessary_deps=Verificando se hay paquetes innecesarios
|
||||
arch.makepkg.optimizing=Optimizing the compilation
|
||||
arch.missing_deps.body=Las siguientes dependencias ({deps}) serán instaladas
|
||||
arch.missing_deps.title=Dependencias faltantes
|
||||
arch.missing_deps_found=Dependencias faltantes para {}
|
||||
arch.mthread_downloaded.error.cache_dir=No fue posible crear el directorio de caché {}
|
||||
arch.mthread_downloaded.error.cancelled=Operación cancelada
|
||||
arch.optdeps.checking=Verificando las dependencias opcionales de {}
|
||||
arch.package.requires_rebuild=Necesita ser reinstalado
|
||||
arch.providers=proveedores
|
||||
arch.substatus.conflicts=Verificando conflictos
|
||||
arch.substatus.disk_space=Verificando espacio disponible en disco
|
||||
arch.substatus.integrity=Verificando la integridad de los paquetes
|
||||
arch.substatus.keyring=Verificando keyring
|
||||
arch.substatus.loading_files=Cargando archivos de los paquetes
|
||||
arch.substatus.pre_hooks=Ejecutando ganchos pre-transacción
|
||||
arch.substatus.retrieve_pkgs=Obteniendo paquetes
|
||||
arch.sync.dep_breakage.reason={} necesita de {}
|
||||
arch.sync_databases.substatus=Sincronizando bases de paquetes
|
||||
arch.sync_databases.substatus.error=No fue posible sincronizar la base de paquetes
|
||||
arch.sync_databases.substatus.synchronized=Sincronizado
|
||||
arch.task.aur.index.status=Generando índice local del AUR
|
||||
arch.task.aur.index.substatus.checking=Buscando actualizaciones
|
||||
arch.task.aur.index.substatus.download=Descargando el índice
|
||||
arch.task.aur.index.substatus.error.download=Error de conexión al descargar el índice
|
||||
arch.task.aur.index.substatus.error.no_data=Error: índice vacío
|
||||
arch.task.aur.index.substatus.gen_index=Generando índice
|
||||
arch.task.checking_settings=Verificando configuraciones
|
||||
arch.task.disabled=Deshabilitado
|
||||
arch.task.disk_cache=Indexando datos de paquetes
|
||||
arch.task.disk_cache.checking=Comprobando índice
|
||||
arch.task.disk_cache.indexed=Indexados
|
||||
arch.task.disk_cache.indexing=Indexando
|
||||
arch.task.disk_cache.reading_files=Lendo archivos
|
||||
arch.task.disk_cache.waiting_aur_index=Esperando {}
|
||||
arch.task.mirrors=Actualizando espejos
|
||||
arch.task.mirrors.cached=Actualizados
|
||||
arch.task.optimizing=Optimizando {}
|
||||
arch.task.sync_sb.status=Actualizando {}
|
||||
arch.uninstall.clean_cached.error=No fue posible eliminar versiones antiguas de {} encontradas en disco
|
||||
arch.uninstall.clean_cached.substatus=Eliminando versiones antiguas del disco
|
||||
arch.uninstall.error.hard_dep_in_hold=No es posible desinstalar {} porque una de sus dependencias está bloqueada (InHold)
|
||||
arch.uninstall.required_by=Los paquetes ({no}) abajo dependen de {pkgs} para funcionar correctamente
|
||||
arch.uninstall.required_by.warn=Es necesario desinstalarlos también para continuar
|
||||
arch.uninstall.unnecessary.all=Los {} seguintes paquetes serán desinstalados
|
||||
arch.uninstall.unnecessary.cancel=Mantener
|
||||
arch.uninstall.unnecessary.l1=¡Paquetes desinstalados con éxito!
|
||||
arch.uninstall.unnecessary.l2=Parece que los paquetes abajo ya no son necesarios
|
||||
arch.uninstall.unnecessary.proceed=Desinstalar
|
||||
arch.uninstalling.conflict=Eliminando paquetes conflictivos
|
||||
arch.uninstalling.conflict.fail=No fue posible desinstalar los paquetes conflictivos: {}
|
||||
arch.update.disabled.tooltip=Solo es posible actualizar este paquete a través de la acción "Actualización rápida de sistema"
|
||||
arch.update_summary.conflict_between=Conflicto entre {} y {}
|
||||
arch.update_summary.to_install.dep_conflict=Conflicto entre las dependencias {} y {}
|
||||
arch.update_summary.to_update.conflicts_dep=Conflicta con la dependencia {} de {}
|
||||
arch.update_summary.to_update.dep_conflicts=La dependencia {} conflicta con {}
|
||||
arch.upgrade.caching_pkgs_data=Caching upgrades data
|
||||
arch.upgrade.error.conflicting_files=Algunos de los paquetes que se están actualizando desean sobrescribir archivos de otros paquetes instalados
|
||||
arch.upgrade.error.dep_breakage=Se han detectado algunos problemas de ruptura de dependencias
|
||||
arch.upgrade.error.dep_breakage.item=La nueva versión de {} rompe la dependencia {} requerida por la versión instalada de {}
|
||||
arch.upgrade.error.dep_breakage.proceed=Continuar de todos modos
|
||||
arch.upgrade.error.dep_breakage.stop=Cancelar actualización
|
||||
arch.upgrade.conflicting_files.proceed=Permitir y continuar
|
||||
arch.upgrade.conflicting_files.stop=Cancelar la actualización
|
||||
arch.upgrade.fail=Falló la actualización del paquete {}
|
||||
arch.upgrade.mthreaddownload.fail=No fue posible descargar todos los paquetes para actualizar
|
||||
arch.upgrade.success=Paquete {} actualizado con éxito
|
||||
arch.upgrade.upgrade_aur_pkgs=Actualizando paquetes de AUR
|
||||
arch.upgrade.upgrade_repo_pkgs=Actualizando paquetes de repositorios
|
||||
arch.warning.disabled={} parece no estar instalado. No será posible administrar paquetes Arch / AUR.
|
||||
arch.warning.aur_missing_dep={} parece no estar instalado. No será posible administrar paquetes del AUR.
|
||||
arch_repo.history.1_version=versión
|
||||
arch_repo.history.2_release=lanzamiento
|
||||
arch_repo.history.3_date=fecha
|
||||
aur.history.1_version=versión
|
||||
aur.history.2_release=lanzamiento
|
||||
aur.history.3_date=fecha
|
||||
category.orphan=huérfano
|
||||
category.out_of_date=desactualizado
|
||||
gem.arch.info=Paquetes de software disponibles para distribuciones basadas en Arch Linux
|
||||
gem.arch.label=Arch
|
||||
gem.arch.type.arch_repo.label=Arch - Repositorio
|
||||
gem.arch.type.aur.label=Arch - AUR
|
||||
@@ -1,316 +0,0 @@
|
||||
arch.action.rebuild_check.allow=Allow reinstallation check
|
||||
arch.action.rebuild_check.allow.desc=Allows to verify the need of reinstalling the package
|
||||
arch.action.rebuild_check.allow.status=Allowing reinstallation check
|
||||
arch.action.rebuild_check.allow.confirm=Allow reinstallation check for {} ?
|
||||
arch.action.rebuild_check.ignore=Ignore reinstallation check
|
||||
arch.action.rebuild_check.ignore.desc=Do not verify if the package needs to be reinstalled on the system
|
||||
arch.action.rebuild_check.ignore.status=Ignoring reinstallation check
|
||||
arch.action.rebuild_check.ignore.confirm=Ignore reinstallation check for {} ?
|
||||
arch.action.db_locked.body.l1=La base de données de paquets du système est verrouillée.
|
||||
arch.action.db_locked.body.l2=Il faut la déverrouiller pour continuer.
|
||||
arch.action.db_locked.confirmation=Déverrouiller et continuer
|
||||
arch.action.db_locked.error=Impossible de déverrouiller la base données.
|
||||
arch.action.db_locked.title=Base de données vérrouillée
|
||||
arch.action.disable_pkgbuild_edition=Décocher PKGBUILD comme éditable
|
||||
arch.action.disable_pkgbuild_edition.confirm=Décocher le PKGBUILD de {} comme éditable ?
|
||||
arch.action.disable_pkgbuild_edition.desc=Do not allow the package's PKGBUILD file to be edited before updating it
|
||||
arch.action.disable_pkgbuild_edition.status=Décocher PKGBUILD comme éditable
|
||||
arch.action.enable_pkgbuild_edition=Cocher PKGBUILD comme éditable
|
||||
arch.action.enable_pkgbuild_edition.confirm=Cocher le PKGBUILD de {} comme éditable ?
|
||||
arch.action.enable_pkgbuild_edition.desc=Allows the package's PKGBUILD file to be edited before updating it
|
||||
arch.action.enable_pkgbuild_edition.status=Le PKGBUILD devient éditable
|
||||
arch.action.reinstall=Reinstall
|
||||
arch.action.reinstall.desc=Tries to install the package again
|
||||
arch.action.reinstall.status=Reinstalling
|
||||
arch.action.reinstall.confirm=Do you want to reinstall {} ?
|
||||
arch.action.reinstall.error.no_apidata=It was not possible to retrieve information of {} from AUR
|
||||
arch.aur.action.edit_pkgbuild.body=Editer le fichier PKGBUILD de {} avant de continuer ?
|
||||
arch.aur.install.pgp.body=Il faut installer {} pour recevoir les clés PGP suivantes
|
||||
arch.aur.install.pgp.receive_fail=Échec de la réception de la clé PGP {}
|
||||
arch.aur.install.pgp.sign_fail=Échec de la signature de la clé PGP {}
|
||||
arch.aur.install.pgp.substatus=Réception de la clé PGP {}
|
||||
arch.aur.install.pgp.success=Clés PGP reçues et signées
|
||||
arch.aur.install.pgp.title=Clés PGP requises
|
||||
arch.aur.install.unknown_key.receive_error=Impossible de recevoir la clé publique {}
|
||||
arch.aur.install.unknown_key.status=Réception de la clé publique {}
|
||||
arch.aur.install.validity_check.body=Des fichiers sources requis pour l'installation de {} ne sont pas sains.
|
||||
arch.aur.install.validity_check.proceed=Continuer quand même ? ( non recommandé )
|
||||
arch.aur.install.validity_check.title=Problèmes d'intégrité {}
|
||||
arch.aur.install.verifying_pgp=Vérification de clés PGP
|
||||
arch.aur.build.list_output=Vérification des fichiers de compilation
|
||||
arch.aur.sync.several_names.popup.body=Le fichier de définition (PKGBUILD) de {} configure la compilation d'autres packages
|
||||
arch.aur.sync.several_names.popup.bt_only_chosen=Compiler seulement {}
|
||||
arch.aur.sync.several_names.popup.bt_selected=Compilation sélectionnée aussi
|
||||
arch.building.package=Compilation de {}
|
||||
arch.can_work.not_arch_distro=Only available for ArchLinux based distributions
|
||||
arch.checking.conflicts=Vérification de conflits aved {}
|
||||
arch.checking.deps=Vérification des dépendances de {}
|
||||
arch.checking.missing_deps=Vérification des dépendances manquantes de {}
|
||||
arch.clone=Copie du dépôt AUR {}
|
||||
arch.category.remove_from_aur=Removed from AUR
|
||||
arch.config.aur=Paquêts AUR
|
||||
arch.config.aur.tip=Permet la gestion des paquets AUR. git doit être installé.
|
||||
arch.config.aur_rebuild_detector=Check reinstallation need
|
||||
arch.config.aur_rebuild_detector.tip=It checks if packages built with old library versions require to be rebuilt. If a package needs to be rebuilt, it will be marked for update ({} must be installed)
|
||||
arch.config.aur_rebuild_detector_no_bin=Ignore binaries ({})
|
||||
arch.config.aur_rebuild_detector_no_bin.tip=If binary packages named as "package-bin" should be ignored by {} ({})
|
||||
arch.config.automatch_providers=Auto-match dependency by name
|
||||
arch.config.automatch_providers.tip=It associates automatically a package to a dependency if both names match. Otherwise all providers for a given dependency will be displayed.
|
||||
arch.config.aur_build_dir=Répertoire de compilation
|
||||
arch.config.aur_build_dir.tip=Définit un répertoire ou les paquets AUR seront compilés. Par défaut: {}.
|
||||
arch.config.aur_build_only_chosen=Compiler uniquement la sélection
|
||||
arch.config.aur_build_only_chosen.tip=Certains paquets AUR ont un PKGBUILD commun partagé avec d'autres packages et ça définit les insctructions de compilation pour chacun d'eux. Cette propriété assure que le paquet sélectionné sera le seul compilé.
|
||||
arch.config.aur_remove_build_dir=Supprimer le répertoire de compilation
|
||||
arch.config.aur_remove_build_dir.tip=Si le repertoire de compilation généré doit être supprimé à la fin des opérations.
|
||||
arch.config.categories_exp=Categories expiration
|
||||
arch.config.categories_exp.tip=It defines the expiration time (in HOURS) of the packages categories mapping file stored in disc. Use 0 so that it is always updated during initialization.
|
||||
arch.config.clean_cache=Supprimer les anciennes versions
|
||||
arch.config.clean_cache.tip=Supprimer les vielles versions d'un package stocké sur le disque pendant la désinstallation
|
||||
arch.config.check_dependency_breakage=Vérification pour éviter qu'une version de casse les dépendances
|
||||
arch.config.check_dependency_breakage.tip=Si, durant la vérification des prérequis de mise à jour, des versions spécifiques de dépendances doivent aussi être vérifiées. Exemple: paquet A dépend de B version 1.0.
|
||||
arch.config.edit_aur_pkgbuild=Éditer PKGBUILD
|
||||
arch.config.edit_aur_pkgbuild.tip=Si le fichier PKGBUILD d'un paquet AUR devrait être affiché pour édition avant installation/mise à jour/downgrade
|
||||
arch.config.aur_idx_exp=Index expiration
|
||||
arch.config.aur_idx_exp.tip=It defines the period (in HOURS) for the AUR index stored in disc to be considered up to date during the initialization process. Use 0 so that it is always updated.
|
||||
arch.config.mirrors_sort_limit=Limite de tri des miroirs
|
||||
arch.config.mirrors_sort_limit.tip=Définit le nombre maximal de miroirs utilisés pour trier vite. 0 pour aucune limite ou vide pour désactiver le tri.
|
||||
arch.config.optimize=Optimizer
|
||||
arch.config.optimize.tip=Utiliser des paramètres optimisés pour rendre l'installation, mise à jour et downgrade des paquets plus rapide. À défaut, les paramètres systèmes seront utilisés.
|
||||
arch.config.pacman_mthread_download=Téléchargement parallèle (repos)
|
||||
arch.config.pacman_mthread_download.tip=Si il faut utiliser un outil qui télécharge les paquets du répos en parallèle (plus rapide). pacman-mirrors doit être installé.
|
||||
arch.config.prefer_repository_provider=Prefer repository dependencies
|
||||
arch.config.prefer_repository_provider.tip=Automatically picks the single package from the repositories among several external ({}) available as the provider for a given dependency
|
||||
arch.config.refresh_mirrors=Actualiser les miroirs au démarrage
|
||||
arch.config.refresh_mirrors.tip=Actualiser les miroirs du paquet une fois par jour au démarrage
|
||||
arch.config.repos=Repos des paquets
|
||||
arch.config.repos.tip=Permet de gerer les paquets du repo
|
||||
arch.config.suggest_optdep_uninstall=Désinstaller les dépendances optionnelles
|
||||
arch.config.suggest_optdep_uninstall.tip=Si les dépendances optionnelles liées au paquets désinstallés dévraient être suggérés pour désinstallation. Seules les dépendances n'étant pas liées à d'autres paquets seront suggérées.
|
||||
arch.config.suggest_unneeded_uninstall=Désinstaller les dépendances inutiles
|
||||
arch.config.suggest_unneeded_uninstall.tip=Si les dépendances apparemment inutiles liées au paquets désinstallés dévraient être suggérés pour désinstallation. Activer cette propriété désactive automatiquement {}.
|
||||
arch.config.suggestions_exp=Suggestions expiration
|
||||
arch.config.suggestions_exp.tip=It defines the period (in hours) in which the suggestions stored in disc will be considered up to date. Use 0 if you always want to update them.
|
||||
arch.config.sync_dbs=Synchroniser les bases de données des paquets
|
||||
arch.config.sync_dbs.tip=Synchronise les bases de données du paquet une fois par jour avant sa première installation, mise à jour ou downgrade. Cette option aide à éviter les erreurs durant ces opérations.
|
||||
arch.config.sync_dbs_start.tip=Synchronise les bases de données du paquet durant l'initialisation journalière
|
||||
arch.custom_action.clean_cache=Vider le cache
|
||||
arch.custom_action.clean_cache.desc=Removes all the downloade package files from the disk cache
|
||||
arch.custom_action.clean_cache.fail=Une erreur est survenue en vidant le cache
|
||||
arch.custom_action.clean_cache.msg1=Le cache est une arborescence où les fichiers d'anciennes versions de paquets sont stockées
|
||||
arch.custom_action.clean_cache.msg2=Le vider libère de l'espace disque sans endommager votre système
|
||||
arch.custom_action.clean_cache.msg3=Ça aide également à débloquer les actions bloquées par le téléchargement d'un paquet corrompu.
|
||||
arch.custom_action.clean_cache.no_dir=Le dossier de cache {} n'existe pas
|
||||
arch.custom_action.clean_cache.status=Supression du cache
|
||||
arch.custom_action.clean_cache.success=Cache vidé !
|
||||
arch.custom_action.refresh_dbs=Synchronse les bases de données du paquet
|
||||
arch.custom_action.refresh_dbs.desc=Synchronizes the available packages on the repositories
|
||||
arch.custom_action.refresh_dbs.failed=Impossible de synchroniser les bases de données du paquet
|
||||
arch.custom_action.refresh_mirrors=Actualisation des miroirs
|
||||
arch.custom_action.refresh_mirrors.desc=Allows to choose the repository mirrors and sort them by the fastest
|
||||
arch.custom_action.refresh_mirrors.failed=Impossible d'actualiser les miroirs
|
||||
arch.custom_action.refresh_mirrors.location.all=Tous
|
||||
arch.custom_action.refresh_mirrors.location.all.tip=Cochez cette option pour ignorer les autres.
|
||||
arch.custom_action.refresh_mirrors.select_label=Vérifier les emplacements désirés
|
||||
arch.custom_action.refresh_mirrors.status.sorting=Tri des miroirs par vitesse
|
||||
arch.custom_action.refresh_mirrors.status.updating=Mise à jour des miroirs
|
||||
arch.custom_action.setup_snapd=Vérifer le support des Snaps
|
||||
arch.custom_action.setup_snapd.desc=Checks if the Snaps support are properly enabled on the system
|
||||
snap.custom_action.setup_snapd.missing_link=Crée le lien {} pour {}
|
||||
arch.custom_action.setup_snapd.status=Vérification du support des Snaps
|
||||
snap.custom_action.setup_snapd.ready=Prêt!
|
||||
snap.custom_action.setup_snapd.ready.body=Le système est prêt pour les Snaps!
|
||||
snap.custom_action.setup_snapd.required_actions=Actions requises pour que les Snaps fonctionnent
|
||||
snap.custom_action.setup_snapd.service_disabled=Active le service {}
|
||||
snap.custom_action.setup_snapd.service_inactive=Démarre le service {}
|
||||
arch.custom_action.upgrade_system=Mise à jour rapide du système
|
||||
arch.custom_action.upgrade_system.desc=Tries to upgrade the system with a single pacman call
|
||||
arch.custom_action.upgrade_system.no_updates=Pas de mises à jour disponibles
|
||||
arch.custom_action.upgrade_system.pkgs=Les paquets suivants vont être mis à jour
|
||||
arch.custom_action.upgrade_system.status=Mise à jour du système
|
||||
arch.custom_action.upgrade_system.substatus=Mise à jour des paquets
|
||||
arch.custom_action.upgrade_system.success.line1=Système à jour!
|
||||
arch.custom_action.upgrade_system.success.line2=L'application de certains changement requierent un redémarrage.
|
||||
arch.custom_action.upgrade_system.success.line3=Redémarrer maintenant ?
|
||||
arch.dialog.providers.line1=Il y a plusieurs fournisseurs pour certains dépendances
|
||||
arch.dialog.providers.line2=Selectionnez ceux que vous voulez
|
||||
arch.downgrade.error=Erreur
|
||||
arch.downgrade.impossible=Imossible de downgrader {}
|
||||
arch.downgrade.install_older=Installation d'une version version antérieure
|
||||
arch.downgrade.reading_commits=Lecture des commits du dépôt
|
||||
arch.downgrade.repo_pkg.no_versions=Aucune version antérieure trouvée sur le disque
|
||||
arch.downgrade.searching_stored=Recherche de version antérieure sur le disque
|
||||
arch.downgrade.version_found=Version actuelle du paquet trouvée
|
||||
arch.aur.error.missing_root_dep={dep} is not installed and is required for installing {aur} packages as the {root} user
|
||||
arch.aur.error.add_builder_user=It was not possible to create the user {user} for building {aur} packages
|
||||
arch.info.00_pkg_build=pkgbuild
|
||||
arch.info.00_url=URL
|
||||
arch.info.01_id=id
|
||||
arch.info.02_name=nom
|
||||
arch.info.03_description=description
|
||||
arch.info.03_version=version
|
||||
arch.info.04_exec=Executable
|
||||
arch.info.04_orphan=orphan
|
||||
arch.info.04_orphan.true=yes
|
||||
arch.info.04_orphan.false=no
|
||||
arch.info.04_out_of_date=out of date
|
||||
arch.info.04_out_of_date.true=yes
|
||||
arch.info.04_out_of_date.false=no
|
||||
arch.info.04_popularity=popularité
|
||||
arch.info.05_votes=votes
|
||||
arch.info.06_package_base=base du paquet
|
||||
arch.info.07_maintainer=maintaineur
|
||||
arch.info.08_first_submitted=première soumission
|
||||
arch.info.09_last_modified=dernière modification
|
||||
arch.info.10_url=url de téléchargement
|
||||
arch.info.11_pkg_build_url=url pkgbuild
|
||||
arch.info.12_makedepends=dépendances de compilation
|
||||
arch.info.13_dependson=dépendances d'installation
|
||||
arch.info.13_pkg_build=pkgbuild
|
||||
arch.info.14_installed_files=Fichiers installés
|
||||
arch.info.14_optdepends=Dépendences optionnelles
|
||||
arch.info.15_checkdepends=Vérification des dépendances
|
||||
arch.info.arch=arch
|
||||
arch.info.arch.any=n'importe
|
||||
arch.info.architecture=architecture
|
||||
arch.info.architecture.any=n'importe
|
||||
arch.info.build date=date de build
|
||||
arch.info.conflicts with=en conflict avec
|
||||
arch.info.depends=dépend
|
||||
arch.info.depends on=dépend de
|
||||
arch.info.description=description
|
||||
arch.info.download size=Taille du téléchargement
|
||||
arch.info.install date=Date d'installation
|
||||
arch.info.install reason=Motif d'installation
|
||||
arch.info.install reason.explicitly installed=Installé explicitement
|
||||
arch.info.install reason.installed as a dependency for another package=dépendance d'un autre paquet
|
||||
arch.info.install script=script d'installation
|
||||
arch.info.install script.no=non
|
||||
arch.info.installed files=fichiers installés
|
||||
arch.info.installed size=taille installée
|
||||
arch.info.last_modified=dernière modification
|
||||
arch.info.license=licence
|
||||
arch.info.licenses=licences
|
||||
arch.info.licenses.custom=personnalisé
|
||||
arch.info.name=nom
|
||||
arch.info.optdepends=dépendances optionnelles
|
||||
arch.info.optional deps=dépendances optionnelles
|
||||
arch.info.optional for=optionnel pour
|
||||
arch.info.options=options
|
||||
arch.info.packager=packageur
|
||||
arch.info.packager.unknown packager=inconnu
|
||||
arch.info.pkgdesc=description
|
||||
arch.info.pkgname=nom
|
||||
arch.info.pkgrel=livraison
|
||||
arch.info.pkgver=version
|
||||
arch.info.provides=fournit
|
||||
arch.info.replaces=remplace
|
||||
arch.info.required by=requis par
|
||||
arch.info.source=source
|
||||
arch.info.url=url
|
||||
arch.info.validated by=validé by
|
||||
arch.info.validated by.signature=signature
|
||||
arch.info.validpgpkeys=clés PGP valides
|
||||
arch.info.version=version
|
||||
arch.install.aur.root_error.body=Interdit d'installer, mettre à jour ou downgrader un patquet en tant que root
|
||||
arch.install.aur.root_error.title=Action non permise
|
||||
arch.install.aur.unknown_key.body=Pour continuer à installer {} il faut faire confiance à la clé publique {}
|
||||
arch.install.aur.unknown_key.title=Clé publique requise
|
||||
arch.install.conflict.popup.body=Les applications {} sont en conflit. Il faut en désinstaller une pour installer l'autre. Continuer ?
|
||||
arch.install.conflict.popup.title=Conflit détecté
|
||||
arch.install.dep_not_found.body.l1=Dépendance requise {dep}{source} absente d AUR ou des dépôts.
|
||||
arch.install.dep_not_found.body.l2=Sans doute un problème de synchronisation de base de données.
|
||||
arch.install.dep_not_found.body.l3=Operation annulée.
|
||||
arch.install.dep_not_found.title=Dependance non trouvée
|
||||
arch.install.dependency.install=Installation de la dépendance {} du paquet
|
||||
arch.install.dependency.install.error=Impossible d'installer les paquets dépendants: {}. Installation de {} interrompue.
|
||||
arch.install.error.conflicting_files=Le paquet {} veut écraser les fichiers d'autres paquets installés
|
||||
arch.install.error.conflicting_files.proceed=Permettre
|
||||
arch.install.error.conflicting_files.stop=Annuler l'installation
|
||||
arch.install.optdep.error=Impossible d'installer les paquets optionnels: {}
|
||||
arch.install.optdeps.request.body=Check the optional associated packages below that you want to install
|
||||
arch.install.optdeps.request.success={pkg} was successfully installed !
|
||||
arch.install.optdeps.request.title=Dépendances optionnelles
|
||||
arch.installing.package=Installation du paquet {}
|
||||
arch.checking_unnecessary_deps=Calcul des paquets devenus inutiles
|
||||
arch.makepkg.optimizing=Optimisation de la compilation
|
||||
arch.missing_deps.body=The following dependencies ({deps}) will be installed
|
||||
arch.missing_deps.title=Dépendances manquantes
|
||||
arch.missing_deps_found=Dépendances manquantes pour {}
|
||||
arch.mthread_downloaded.error.cache_dir=Impossible de créer le dossier de cache {}
|
||||
arch.mthread_downloaded.error.cancelled=Operation annulée
|
||||
arch.optdeps.checking=Verification des dépendances optionnelles de {}
|
||||
arch.package.requires_rebuild=It needs to be reinstalled
|
||||
arch.providers=fournisseurs
|
||||
arch.substatus.conflicts=Verification des conflits
|
||||
arch.substatus.disk_space=Verification de l'espace disque disponible
|
||||
arch.substatus.integrity=Recherche de paquets corrompus
|
||||
arch.substatus.keyring=Verification du trousseau de clés
|
||||
arch.substatus.loading_files=Chargement des fichers du paquet
|
||||
arch.substatus.pre_hooks=Éxécution des pre-transaction hooks
|
||||
arch.substatus.retrieve_pkgs=Retrieving packages
|
||||
arch.sync.dep_breakage.reason={} requiert {}
|
||||
arch.sync_databases.substatus=Synchronisation des bases de données du paquet
|
||||
arch.sync_databases.substatus.error=Impossible de synchroniser les bases de données du paquet
|
||||
arch.sync_databases.substatus.synchronized=Synchronized
|
||||
arch.task.aur.index.status=Generating local AUR index
|
||||
arch.task.aur.index.substatus.checking=Checking for updates
|
||||
arch.task.aur.index.substatus.download=Downloading the AUR index
|
||||
arch.task.aur.index.substatus.error.download=Connection error while downloading the index
|
||||
arch.task.aur.index.substatus.error.no_data=Error: empty index
|
||||
arch.task.aur.index.substatus.gen_index=Generating index
|
||||
arch.task.checking_settings=Checking settings
|
||||
arch.task.disabled=Disabled
|
||||
arch.task.disk_cache=Indexation des données des paquets
|
||||
arch.task.disk_cache.checking=Verification de l'index
|
||||
arch.task.disk_cache.indexed=Indexé
|
||||
arch.task.disk_cache.indexing=Indexation
|
||||
arch.task.disk_cache.reading_files=Lecture des fichiers
|
||||
arch.task.disk_cache.waiting_aur_index=Waiting {}
|
||||
arch.task.mirrors=Mise à jour des miroirs
|
||||
arch.task.mirrors.cached=Refreshed
|
||||
arch.task.optimizing=Optimisation {}
|
||||
arch.task.sync_sb.status=Mise à jour {}
|
||||
arch.uninstall.clean_cached.error=Impossible de supprimer les anciennes version de {} trouvées sur le disque
|
||||
arch.uninstall.clean_cached.substatus=Suppression des anciennes versions
|
||||
arch.uninstall.error.hard_dep_in_hold=Impossible de désinstaller {} une de ses dépendances est marquée "InHold"
|
||||
arch.uninstall.required_by=Les paquets ({no}) listés ci dessous dépendent de {pkgs} pour fonctionner
|
||||
arch.uninstall.required_by.warn=Il faut les désinstaller pour continuer
|
||||
arch.uninstall.unnecessary.all=Les {} paquets suivants seront désinstallés
|
||||
arch.uninstall.unnecessary.cancel=Garder
|
||||
arch.uninstall.unnecessary.l1=Paquets désinstallés!
|
||||
arch.uninstall.unnecessary.l2=Les paquets suivants n'ont plus l'air utiles
|
||||
arch.uninstall.unnecessary.proceed=Désinstaller
|
||||
arch.uninstalling.conflict=Désinstaller les paquets en conflit
|
||||
arch.uninstalling.conflict.fail=Impossible de désinstaller les paquets en conflit: {}
|
||||
arch.update.disabled.tooltip=Ce paquet peut seulement être mis à jour par l'action "Mise à jour système rapide"
|
||||
arch.update_summary.conflict_between=Conflit entre {} et {}
|
||||
arch.update_summary.to_install.dep_conflict=Conflit entre les dépendances {} et {}
|
||||
arch.update_summary.to_update.conflicts_dep=Conflit avec les dépendances{} et {}
|
||||
arch.update_summary.to_update.dep_conflicts=La dépendance {} est en conflit avec {}
|
||||
arch.upgrade.caching_pkgs_data=Mise en cache des données de mise à jour
|
||||
arch.upgrade.error.conflicting_files=Certains des paquets en train d'être mis à jour veulent écraser des fichiers de paquets déjà installés
|
||||
arch.upgrade.error.dep_breakage=Des problèmes de casse de dépendances ont été détectés
|
||||
arch.upgrade.error.dep_breakage.item=La nouvelle version de {} casse la dépendance {} requise par la version installée de {}
|
||||
arch.upgrade.error.dep_breakage.proceed=Continuer quand même
|
||||
arch.upgrade.error.dep_breakage.stop=Annuler la mise à jour
|
||||
arch.upgrade.conflicting_files.proceed=Permettre et continuer
|
||||
arch.upgrade.conflicting_files.stop=Annuler la mise à jour
|
||||
arch.upgrade.fail=Échec de la mise à jour du paquet {}
|
||||
arch.upgrade.mthreaddownload.fail=Impossible de télécharger tous les paquets pour la mise à jour
|
||||
arch.upgrade.success=Paquet {} mis à jour avec succès
|
||||
arch.upgrade.upgrade_aur_pkgs=Mise à jour des paquets AUR
|
||||
arch.upgrade.upgrade_repo_pkgs=Mise à jour des paquets de dépots
|
||||
arch.warning.disabled={} n'a pas l'air d'être installé. Il ne sera pas possible de gérer les paquets Arch / AUR.
|
||||
arch.warning.aur_missing_dep={} seems not to be installed. It will not be possible to manage AUR packages.
|
||||
arch_repo.history.1_version=version
|
||||
arch_repo.history.2_release=livraison
|
||||
arch_repo.history.3_date=date
|
||||
aur.history.1_version=version
|
||||
aur.history.2_release=livraison
|
||||
aur.history.3_date=date
|
||||
category.orphan=orphan
|
||||
category.out_of_date=out of date
|
||||
gem.arch.info=Paquets logiciels disponibles pour les distributions basées sur Arch Linux
|
||||
gem.arch.label=Arch
|
||||
gem.arch.type.arch_repo.label=Arch - Dépôt
|
||||
gem.arch.type.aur.label=Arch - AUR
|
||||
@@ -1,316 +0,0 @@
|
||||
arch.action.rebuild_check.allow=Allow reinstallation check
|
||||
arch.action.rebuild_check.allow.desc=Allows to verify the need of reinstalling the package
|
||||
arch.action.rebuild_check.allow.status=Allowing reinstallation check
|
||||
arch.action.rebuild_check.allow.confirm=Allow reinstallation check for {} ?
|
||||
arch.action.rebuild_check.ignore=Ignore reinstallation check
|
||||
arch.action.rebuild_check.ignore.desc=Do not verify if the package needs to be reinstalled on the system
|
||||
arch.action.rebuild_check.ignore.status=Ignoring reinstallation check
|
||||
arch.action.rebuild_check.ignore.confirm=Ignore reinstallation check for {} ?
|
||||
arch.action.db_locked.body.l1=The system's package database is locked.
|
||||
arch.action.db_locked.body.l2=It is necessary to unlock it to continue.
|
||||
arch.action.db_locked.confirmation=Unlock and continue
|
||||
arch.action.db_locked.error=It was not possible to unlock the database.
|
||||
arch.action.db_locked.title=Database locked
|
||||
arch.action.disable_pkgbuild_edition=Unmark PKGBUILD as editable
|
||||
arch.action.disable_pkgbuild_edition.confirm=Unmark PKGBUILD of {} as editable ?
|
||||
arch.action.disable_pkgbuild_edition.desc=Do not allow the package's PKGBUILD file to be edited before updating it
|
||||
arch.action.disable_pkgbuild_edition.status=Unmarking PKGBUILD as editable
|
||||
arch.action.enable_pkgbuild_edition=Mark PKGBUILD as editable
|
||||
arch.action.enable_pkgbuild_edition.confirm=Mark PKGBUILD of {} as editable ?
|
||||
arch.action.enable_pkgbuild_edition.desc=Allows the package's PKGBUILD file to be edited before updating it
|
||||
arch.action.enable_pkgbuild_edition.status=Marking PKGBUILD as editable
|
||||
arch.action.reinstall=Reinstall
|
||||
arch.action.reinstall.desc=Tries to install the package again
|
||||
arch.action.reinstall.status=Reinstalling
|
||||
arch.action.reinstall.confirm=Do you want to reinstall {} ?
|
||||
arch.action.reinstall.error.no_apidata=It was not possible to retrieve information of {} from AUR
|
||||
arch.aur.action.edit_pkgbuild.body=Edit the PKGBUILD file of {} before continuing ?
|
||||
arch.aur.install.pgp.body=Per installare {} è necessario ricevere le seguenti chiavi PGP
|
||||
arch.aur.install.pgp.receive_fail=Impossibile ricevere la chiave PGP {}
|
||||
arch.aur.install.pgp.sign_fail=Impossibile firmare la chiave PGP {}
|
||||
arch.aur.install.pgp.substatus=Ricezione della chiave PGP {}
|
||||
arch.aur.install.pgp.success=Chiavi PGP ricevute e firmate
|
||||
arch.aur.install.pgp.title=Chiavi PGP richieste
|
||||
arch.aur.install.unknown_key.receive_error=Impossibile ricevere la chiave pubblica {}
|
||||
arch.aur.install.unknown_key.status=Ricezione della chiave pubblica {}
|
||||
arch.aur.install.validity_check.body=Alcuni dei file di origine necessari per l'installazione di {} non sono integri.
|
||||
arch.aur.install.validity_check.proceed=Vuoi continuare comunque? ( non consigliato )
|
||||
arch.aur.install.validity_check.title=Problemi di integrità {}
|
||||
arch.aur.install.verifying_pgp=Verifica chiavi PGP
|
||||
arch.aur.build.list_output=Checking built files
|
||||
arch.aur.sync.several_names.popup.body=The definition file (PKGBUILD) of {} configures the build of other packages
|
||||
arch.aur.sync.several_names.popup.bt_only_chosen=Build only {}
|
||||
arch.aur.sync.several_names.popup.bt_selected=Build selected too
|
||||
arch.building.package=Pacchetto costruito {}
|
||||
arch.can_work.not_arch_distro=Only available for ArchLinux based distributions
|
||||
arch.checking.conflicts=Verifica di eventuali conflitti con {}
|
||||
arch.checking.deps=Verifica di {} dipendenze
|
||||
arch.checking.missing_deps=Verifica delle dipendenze mancanti di {}
|
||||
arch.clone=Clonazione del repository AUR {}
|
||||
arch.category.remove_from_aur=Removed from AUR
|
||||
arch.config.aur=AUR packages
|
||||
arch.config.aur.tip=It allows to manage AUR packages. git must be installed.
|
||||
arch.config.aur_rebuild_detector=Check reinstallation need
|
||||
arch.config.aur_rebuild_detector.tip=It checks if packages built with old library versions require to be rebuilt. If a package needs to be rebuilt, it will be marked for update ({} must be installed)
|
||||
arch.config.aur_rebuild_detector_no_bin=Ignore binaries ({})
|
||||
arch.config.aur_rebuild_detector_no_bin.tip=If binary packages named as "package-bin" should be ignored by {} ({})
|
||||
arch.config.automatch_providers=Auto-match dependency by name
|
||||
arch.config.automatch_providers.tip=It associates automatically a package to a dependency if both names match. Otherwise all providers for a given dependency will be displayed.
|
||||
arch.config.aur_build_dir=Build directory
|
||||
arch.config.aur_build_dir.tip=It define a custom directory where the AUR packages will be built. Default: {}.
|
||||
arch.config.aur_build_only_chosen=Build only chosen
|
||||
arch.config.aur_build_only_chosen.tip=Some AUR packages have a common PKGBUILD shared with other packages and that defines build instructions for each one. This property enabled will ensure that only the chosen package will be built.
|
||||
arch.config.aur_remove_build_dir=Remove build directory
|
||||
arch.config.aur_remove_build_dir.tip=If a package's generated build directory should be removed after the operations is finished.
|
||||
arch.config.categories_exp=Categories expiration
|
||||
arch.config.categories_exp.tip=It defines the expiration time (in HOURS) of the packages categories mapping file stored in disc. Use 0 so that it is always updated during initialization.
|
||||
arch.config.clean_cache=Rimuovi le vecchie versioni
|
||||
arch.config.clean_cache.tip=Se le vecchie versioni di un pacchetto memorizzate sul disco devono essere rimosse durante la disinstallazione
|
||||
arch.config.check_dependency_breakage=Check dependency version breakage
|
||||
arch.config.check_dependency_breakage.tip=If, during the verification of upgrade requirements, specific versions of dependencies must also be checked. Example: package A depends on version 1.0 of B.
|
||||
arch.config.edit_aur_pkgbuild=Edit PKGBUILD
|
||||
arch.config.edit_aur_pkgbuild.tip=If the PKGBUILD file of an AUR package should be displayed for editing before its installation/upgrade/downgrade
|
||||
arch.config.aur_idx_exp=Index expiration
|
||||
arch.config.aur_idx_exp.tip=It defines the period (in HOURS) for the AUR index stored in disc to be considered up to date during the initialization process. Use 0 so that it is always updated.
|
||||
arch.config.mirrors_sort_limit=Mirrors sort limit
|
||||
arch.config.mirrors_sort_limit.tip=Defines the maximum number of mirrors that will be used for speed sorting. Use 0 for no limit or leave it blank to disable sorting.
|
||||
arch.config.optimize=Optimize
|
||||
arch.config.optimize.tip=Verranno utilizzate le impostazioni ottimizzate per velocizzare l'installazione, l'aggiornamento e l'inversione dei pacchetti, altrimenti verranno utilizzate le impostazioni di sistema
|
||||
arch.config.pacman_mthread_download=Multithreaded download (repositories)
|
||||
arch.config.pacman_mthread_download.tip=Whether the repository packages should be downloaded with a tool that works with threads (it may be faster). pacman-mirrors must be installed.
|
||||
arch.config.prefer_repository_provider=Prefer repository dependencies
|
||||
arch.config.prefer_repository_provider.tip=Automatically picks the single package from the repositories among several external ({}) available as the provider for a given dependency
|
||||
arch.config.refresh_mirrors=Refresh mirrors on startup
|
||||
arch.config.refresh_mirrors.tip=Refresh the package mirrors once a day on startup
|
||||
arch.config.repos=Repositories packages
|
||||
arch.config.repos.tip=It allows to manage packages from the repositories set
|
||||
arch.config.suggest_optdep_uninstall=Uninstall optional dependencies
|
||||
arch.config.suggest_optdep_uninstall.tip=If the optional dependencies associated with uninstalled packages should be suggested for uninstallation. Only the optional dependencies that are not dependencies of other packages will be suggested.
|
||||
arch.config.suggest_unneeded_uninstall=Uninstall unneeded dependencies
|
||||
arch.config.suggest_unneeded_uninstall.tip=If the dependencies apparently no longer necessary associated with the uninstalled packages should be suggested for uninstallation. When this property is enabled it automatically disables the property {}.
|
||||
arch.config.suggestions_exp=Suggestions expiration
|
||||
arch.config.suggestions_exp.tip=It defines the period (in hours) in which the suggestions stored in disc will be considered up to date. Use 0 if you always want to update them.
|
||||
arch.config.sync_dbs=Synchronize packages databases
|
||||
arch.config.sync_dbs.tip=Synchronizes the package databases once a day before the first package installation, upgrade or downgrade. This option helps to prevent errors during these operations.
|
||||
arch.config.sync_dbs_start.tip=Synchronizes the package databases during the initialization once a day
|
||||
arch.custom_action.clean_cache=Clean cache
|
||||
arch.custom_action.clean_cache.desc=Removes all the downloade package files from the disk cache
|
||||
arch.custom_action.clean_cache.fail=An error occurred while cleaning the cache
|
||||
arch.custom_action.clean_cache.msg1=The cache is a system directory where files of old package versions are stored
|
||||
arch.custom_action.clean_cache.msg2=Cleaning it frees storage space without harming your system
|
||||
arch.custom_action.clean_cache.msg3=It also helps when there are downloaded packages with integrity issues blocking an action
|
||||
arch.custom_action.clean_cache.no_dir=The cache directory {} does not exist
|
||||
arch.custom_action.clean_cache.status=Cleaning cache
|
||||
arch.custom_action.clean_cache.success=Cache successfully cleaned !
|
||||
arch.custom_action.refresh_dbs=Synchronize package databases
|
||||
arch.custom_action.refresh_dbs.desc=Synchronizes the available packages on the repositories
|
||||
arch.custom_action.refresh_dbs.failed=It was not possible to synchronize the package databases
|
||||
arch.custom_action.refresh_mirrors=Refresh mirrors
|
||||
arch.custom_action.refresh_mirrors.desc=Allows to choose the repository mirrors and sort them by the fastest
|
||||
arch.custom_action.refresh_mirrors.failed=It was not possible to refresh the mirrors
|
||||
arch.custom_action.refresh_mirrors.location.all=All
|
||||
arch.custom_action.refresh_mirrors.location.all.tip=If this option is checked, the others will be ignored.
|
||||
arch.custom_action.refresh_mirrors.select_label=Check the desired locations
|
||||
arch.custom_action.refresh_mirrors.status.sorting=Sorting mirrors by speed
|
||||
arch.custom_action.refresh_mirrors.status.updating=Sorting mirrors by speed
|
||||
arch.custom_action.setup_snapd=Check Snaps support
|
||||
arch.custom_action.setup_snapd.desc=Checks if the Snaps support are properly enabled on the system
|
||||
snap.custom_action.setup_snapd.missing_link=Create the link {} for {}
|
||||
arch.custom_action.setup_snapd.status=Checking Snaps support
|
||||
snap.custom_action.setup_snapd.ready=Ready!
|
||||
snap.custom_action.setup_snapd.ready.body=The system is ready to work with Snaps!
|
||||
snap.custom_action.setup_snapd.required_actions=Actions required for Snaps to work correctly
|
||||
snap.custom_action.setup_snapd.service_disabled=Enable the service {}
|
||||
snap.custom_action.setup_snapd.service_inactive=Start the service {}
|
||||
arch.custom_action.upgrade_system=Quick system upgrade
|
||||
arch.custom_action.upgrade_system.desc=Tries to upgrade the system with a single pacman call
|
||||
arch.custom_action.upgrade_system.no_updates=There are no updates available
|
||||
arch.custom_action.upgrade_system.pkgs=The packages below will be upgraded
|
||||
arch.custom_action.upgrade_system.status=Upgrading system
|
||||
arch.custom_action.upgrade_system.substatus=Upgrading packages
|
||||
arch.custom_action.upgrade_system.success.line1=System successfully upgraded!
|
||||
arch.custom_action.upgrade_system.success.line2=Some changes may require a system restart to take effect.
|
||||
arch.custom_action.upgrade_system.success.line3=Restart now ?
|
||||
arch.dialog.providers.line1=There are multiple providers for some dependencies
|
||||
arch.dialog.providers.line2=Select those you want
|
||||
arch.downgrade.error=Errore
|
||||
arch.downgrade.impossible=Non è possibile effettuare il downgrade {}
|
||||
arch.downgrade.install_older=Installazione della versione precedente
|
||||
arch.downgrade.reading_commits=Reading the repository commits
|
||||
arch.downgrade.repo_pkg.no_versions=Nessuna versione precedente trovata sul disco
|
||||
arch.downgrade.searching_stored=Ricerca di versioni precedenti su disco
|
||||
arch.downgrade.version_found=Trovata la versione del pacchetto corrente
|
||||
arch.aur.error.missing_root_dep={dep} is not installed and is required for installing {aur} packages as the {root} user
|
||||
arch.aur.error.add_builder_user=It was not possible to create the user {user} for building {aur} packages
|
||||
arch.info.00_pkg_build=pkgbuild
|
||||
arch.info.00_url=URL
|
||||
arch.info.01_id=id
|
||||
arch.info.02_name=nome
|
||||
arch.info.03_description=descrizione
|
||||
arch.info.03_version=versione
|
||||
arch.info.04_exec=Executable
|
||||
arch.info.04_orphan=orphan
|
||||
arch.info.04_orphan.true=yes
|
||||
arch.info.04_orphan.false=no
|
||||
arch.info.04_out_of_date=out of date
|
||||
arch.info.04_out_of_date.true=yes
|
||||
arch.info.04_out_of_date.false=no
|
||||
arch.info.04_popularity=popolarità
|
||||
arch.info.05_votes=voti
|
||||
arch.info.06_package_base=pacchetto base
|
||||
arch.info.07_maintainer=manutentore
|
||||
arch.info.08_first_submitted=prima presentata
|
||||
arch.info.09_last_modified=Ultima modifica
|
||||
arch.info.10_url=URL per il download
|
||||
arch.info.11_pkg_build_url=url PKGBUILD
|
||||
arch.info.12_makedepends=le dipendenze di compilazione
|
||||
arch.info.13_dependson=dipendenze di installazione
|
||||
arch.info.13_pkg_build=pkgbuild
|
||||
arch.info.14_installed_files=file installati
|
||||
arch.info.14_optdepends=dipendenze opzionali
|
||||
arch.info.15_checkdepends=il controllo delle dipendenze
|
||||
arch.info.arch=arco
|
||||
arch.info.arch.any=qualunque
|
||||
arch.info.architecture=architettura
|
||||
arch.info.architecture.any=qualunque
|
||||
arch.info.build date=data di costruzione
|
||||
arch.info.conflicts with=conflitti con
|
||||
arch.info.depends=dipende
|
||||
arch.info.depends on=dipende da
|
||||
arch.info.description=descrizione
|
||||
arch.info.download size=Download size
|
||||
arch.info.install date=data di installazione
|
||||
arch.info.install reason=installare ragione
|
||||
arch.info.install reason.explicitly installed=esplicitamente installato
|
||||
arch.info.install reason.installed as a dependency for another package=dipendenza di un altro pacchetto
|
||||
arch.info.install script=script di installazione
|
||||
arch.info.install script.no=nessuno
|
||||
arch.info.installed files=file installati
|
||||
arch.info.installed size=taglia installata
|
||||
arch.info.last_modified=Ultima modifica
|
||||
arch.info.license=licenza
|
||||
arch.info.licenses=licenze
|
||||
arch.info.licenses.custom=costume
|
||||
arch.info.name=nome
|
||||
arch.info.optdepends=dipendenze opzionali
|
||||
arch.info.optional deps=dipendenze opzionali
|
||||
arch.info.optional for=per facoltativo
|
||||
arch.info.options=opzioni
|
||||
arch.info.packager=packager
|
||||
arch.info.packager.unknown packager=sconosciuto
|
||||
arch.info.pkgdesc=descrizione
|
||||
arch.info.pkgname=nome
|
||||
arch.info.pkgrel=pubblicazione
|
||||
arch.info.pkgver=versione
|
||||
arch.info.provides=fornisce
|
||||
arch.info.replaces=sostituisce
|
||||
arch.info.required by=richiesto dalla
|
||||
arch.info.source=fonte
|
||||
arch.info.url=url
|
||||
arch.info.validated by=convalidato da
|
||||
arch.info.validated by.signature=firma
|
||||
arch.info.validpgpkeys=chiavi PGP valide
|
||||
arch.info.version=versione
|
||||
arch.install.aur.root_error.body=Non è consentito installare, aggiornare o degradare un pacchetto come utente root
|
||||
arch.install.aur.root_error.title=Azione non consentita
|
||||
arch.install.aur.unknown_key.body=Per continuare {} l'installazione è necessaria per fidarsi della seguente chiave pubblica {}
|
||||
arch.install.aur.unknown_key.title=Chiave pubblica richiesta
|
||||
arch.install.conflict.popup.body=Le applicazioni {} sono in conflitto. È necessario disinstallarne una per installare l'altra. Continua ?
|
||||
arch.install.conflict.popup.title=Conflitto rilevato
|
||||
arch.install.dep_not_found.body.l1=La dipendenza richiesta {dep}{source} non è stata trovata in AUR né nei depositos.
|
||||
arch.install.dep_not_found.body.l2=It might be a package database synchronization problem.
|
||||
arch.install.dep_not_found.body.l3=Operation cancelled.
|
||||
arch.install.dep_not_found.title=Dipendenza non trovata
|
||||
arch.install.dependency.install=Installazione della dipendenza pacchetto {}
|
||||
arch.install.dependency.install.error=Could not install the dependent packages: {}. Installation of {} aborted.
|
||||
arch.install.error.conflicting_files=The package {} wants to overwrite files from other installed packages
|
||||
arch.install.error.conflicting_files.proceed=Allow
|
||||
arch.install.error.conflicting_files.stop=Cancel installation
|
||||
arch.install.optdep.error=Could not install the optional packages: {}
|
||||
arch.install.optdeps.request.body=Check the optional associated packages below that you want to install
|
||||
arch.install.optdeps.request.success={pkg} was successfully installed !
|
||||
arch.install.optdeps.request.title=Dipendenze opzionali
|
||||
arch.installing.package=Installazione del pacchetto {}
|
||||
arch.checking_unnecessary_deps=Checking if there are packages no longer needed
|
||||
arch.makepkg.optimizing=Ottimizzando la compilazione
|
||||
arch.missing_deps.body=The following dependencies ({deps}) will be installed
|
||||
arch.missing_deps.title=Dipendenze mancanti
|
||||
arch.missing_deps_found=Dipendenze mancanti per {}
|
||||
arch.mthread_downloaded.error.cache_dir=It was not possible to create the cache directory {}
|
||||
arch.mthread_downloaded.error.cancelled=Operation cancelled
|
||||
arch.optdeps.checking=Verifica di {} dipendenze opzionali
|
||||
arch.package.requires_rebuild=It needs to be reinstalled
|
||||
arch.providers=providers
|
||||
arch.substatus.conflicts=Checking for conflicts
|
||||
arch.substatus.disk_space=Checking available disk space
|
||||
arch.substatus.integrity=Checking packages integrity
|
||||
arch.substatus.keyring=Checking keyring
|
||||
arch.substatus.loading_files=Loading package files
|
||||
arch.substatus.pre_hooks=Running pre-transaction hooks
|
||||
arch.substatus.retrieve_pkgs=Retrieving packages
|
||||
arch.sync.dep_breakage.reason={} requires {}
|
||||
arch.sync_databases.substatus=Synchronizing package databases
|
||||
arch.sync_databases.substatus.error=It was not possible to synchronize the package database
|
||||
arch.sync_databases.substatus.synchronized=Synchronized
|
||||
arch.task.aur.index.status=Generating local AUR index
|
||||
arch.task.aur.index.substatus.checking=Checking for updates
|
||||
arch.task.aur.index.substatus.download=Downloading the AUR index
|
||||
arch.task.aur.index.substatus.error.download=Connection error while downloading the index
|
||||
arch.task.aur.index.substatus.error.no_data=Error: empty index
|
||||
arch.task.aur.index.substatus.gen_index=Generating index
|
||||
arch.task.checking_settings=Checking settings
|
||||
arch.task.disabled=Disabled
|
||||
arch.task.disk_cache=Indexing packages data
|
||||
arch.task.disk_cache.checking=Checking index
|
||||
arch.task.disk_cache.indexed=Indexed
|
||||
arch.task.disk_cache.indexing=Indexing
|
||||
arch.task.disk_cache.reading_files=Reading files
|
||||
arch.task.disk_cache.waiting_aur_index=Waiting {}
|
||||
arch.task.mirrors=Aggiornando i mirror
|
||||
arch.task.mirrors.cached=Refreshed
|
||||
arch.task.optimizing=Ottimizzando {}
|
||||
arch.task.sync_sb.status=Aggiornando {}
|
||||
arch.uninstall.clean_cached.error=Non è stato possibile rimuovere le vecchie {} versioni trovate sul disco
|
||||
arch.uninstall.clean_cached.substatus=Rimozione di versioni precedenti dal disco
|
||||
arch.uninstall.error.hard_dep_in_hold=It is not possible to uninstall {} because one of its dependencies is marked as "InHold"
|
||||
arch.uninstall.required_by=The packages ({no}) below depend on {pkgs} to work properly
|
||||
arch.uninstall.required_by.warn=It is necessary to uninstall them as well to proceed
|
||||
arch.uninstall.unnecessary.all=The following {} packages will be uninstalled
|
||||
arch.uninstall.unnecessary.cancel=Keep
|
||||
arch.uninstall.unnecessary.l1=Packages successfully uninstalled!
|
||||
arch.uninstall.unnecessary.l2=The packages below seem to be no longer necessary
|
||||
arch.uninstall.unnecessary.proceed=Uninstall
|
||||
arch.uninstalling.conflict=Uninstalling conflicting packages
|
||||
arch.uninstalling.conflict.fail=It was not possible to uninstall the conflicting packages: {}
|
||||
arch.update.disabled.tooltip=This package can oly be upgrade through the action "Quick system upgrade"
|
||||
arch.update_summary.conflict_between=Conflict between {} and {}
|
||||
arch.update_summary.to_install.dep_conflict=Conflict between the dependencies {} and {}
|
||||
arch.update_summary.to_update.conflicts_dep=Conflicts with the dependency {} of {}
|
||||
arch.update_summary.to_update.dep_conflicts=Dependency {} conflicts with {}
|
||||
arch.upgrade.caching_pkgs_data=Caching updates data
|
||||
arch.upgrade.error.conflicting_files=Some of the packages being upgraded want to overwrite files of another installed packages
|
||||
arch.upgrade.error.dep_breakage=Some dependency breakage issues have been detected
|
||||
arch.upgrade.error.dep_breakage.item=The new version of {} breaks the dependency {} required by the installed version of {}
|
||||
arch.upgrade.error.dep_breakage.proceed=Proceed anyway
|
||||
arch.upgrade.error.dep_breakage.stop=Cancel upgrade
|
||||
arch.upgrade.conflicting_files.proceed=Allow and continue
|
||||
arch.upgrade.conflicting_files.stop=Cancel upgrading
|
||||
arch.upgrade.fail=Package {} upgrade failed
|
||||
arch.upgrade.mthreaddownload.fail=It was not possible to download all packages for upgrading
|
||||
arch.upgrade.success=Package {} successfully upgraded
|
||||
arch.upgrade.upgrade_aur_pkgs=Upgrading AUR packages
|
||||
arch.upgrade.upgrade_repo_pkgs=Upgrading packages from repositories
|
||||
arch.warning.disabled={} sembra non essere installato. Non sarà possibile gestire i pacchetti Arch/AUR.
|
||||
arch.warning.aur_missing_dep={} seems not to be installed. It will not be possible to manage AUR packages.
|
||||
arch_repo.history.1_version=versione
|
||||
arch_repo.history.2_release=rilascio
|
||||
arch_repo.history.3_date=data
|
||||
aur.history.1_version=versione
|
||||
aur.history.2_release=rilascio
|
||||
aur.history.3_date=data
|
||||
category.orphan=orphan
|
||||
category.out_of_date=out of date
|
||||
gem.arch.info=Software packages available for distributions based on Arch Linux
|
||||
gem.arch.label=Arch
|
||||
gem.arch.type.arch_repo.label=Arch - Deposito
|
||||
gem.arch.type.aur.label=Arch - AUR
|
||||
@@ -1,315 +0,0 @@
|
||||
arch.action.rebuild_check.allow=Permitir verificação de reinstalação
|
||||
arch.action.rebuild_check.allow.desc=Permite a verificação da necessidade de reinstalar o pacote
|
||||
arch.action.rebuild_check.allow.status=Permitindo verificação de reinstalação
|
||||
arch.action.rebuild_check.allow.confirm=Permitir verificação de reinstalação para {} ?
|
||||
arch.action.rebuild_check.ignore=Ignorar verificação de reinstalação
|
||||
arch.action.rebuild_check.ignore.desc=Não verificar se o pacote precisa ser reinstalado no sistema
|
||||
arch.action.rebuild_check.ignore.status=Ignorando verificação de reinstalação
|
||||
arch.action.rebuild_check.ignore.confirm=Ignorar verificação de reinstalação para {} ?
|
||||
arch.action.db_locked.body.l1=O banco de dados de pacotes do sistema está bloqueado.
|
||||
arch.action.db_locked.body.l2=É necessário desbloquea-lo para continuar.
|
||||
arch.action.db_locked.confirmation=Desbloquear e continuar
|
||||
arch.action.db_locked.error=Não foi possível desbloquear o banco de dados.
|
||||
arch.action.db_locked.title=Banco de dados bloqueado
|
||||
arch.action.disable_pkgbuild_edition=Desmarcar PKGBUILD como editável
|
||||
arch.action.disable_pkgbuild_edition.confirm=Desmarcar o PKGBUILD de {} como editável ?
|
||||
arch.action.disable_pkgbuild_edition.desc=Não permite a edição do arquivo PKGBUILD do pacote antes de atualiza-lo
|
||||
arch.action.disable_pkgbuild_edition.status=Desmarcando PKGBUILD como editável
|
||||
arch.action.enable_pkgbuild_edition=Marcar PKGBUILD como editável
|
||||
arch.action.enable_pkgbuild_edition.confirm=Marcar o PKGBUILD de {} como editável ?
|
||||
arch.action.enable_pkgbuild_edition.desc=Permite a edição do arquivo PKGBUILD do pacote antes de atualiza-lo
|
||||
arch.action.enable_pkgbuild_edition.status=Marcando PKGBUILD como editável
|
||||
arch.action.reinstall=Reinstalar
|
||||
arch.action.reinstall.desc=Tenta instalar o pacote novamente
|
||||
arch.action.reinstall.status=Reinstalando
|
||||
arch.action.reinstall.confirm=Deseja reinstalar {} ?
|
||||
arch.action.reinstall.error.no_apidata=Não foi possível obter informações de {} do AUR
|
||||
arch.aur.action.edit_pkgbuild.body=Editar o arquivo PKGBUILD de {} antes de continuar ?
|
||||
arch.aur.install.pgp.body=Para instalar {} é necessário receber as seguintes chaves PGP
|
||||
arch.aur.install.pgp.receive_fail=Não foi possível receber a chave PGP {}
|
||||
arch.aur.install.pgp.sign_fail=Não foi possível assinar a chave PGP {}
|
||||
arch.aur.install.pgp.substatus=Recebendo chave PGP {}
|
||||
arch.aur.install.pgp.success=Chaves PGP recebidas e assinadas
|
||||
arch.aur.install.pgp.title=Chaves PGP necessárias
|
||||
arch.aur.install.unknown_key.receive_error=Não fui possível receber a chave pública {}
|
||||
arch.aur.install.unknown_key.status=Recebendo a chave pública {}
|
||||
arch.aur.install.validity_check.body=Alguns dos arquivos-fonte necessários para a instalação de {} não estão íntegros.
|
||||
arch.aur.install.validity_check.proceed=Você deseja continuar mesmo assim ? ( não recomendado )
|
||||
arch.aur.install.validity_check.title=Problemas de integridade {}
|
||||
arch.aur.install.verifying_pgp=Verificando chaves PGP
|
||||
arch.aur.build.list_output=Verificando arquivos construídos
|
||||
arch.aur.sync.several_names.popup.body=O arquivo de definição (PKGBUILD) de {} configura a construção de outros pacotes
|
||||
arch.aur.sync.several_names.popup.bt_only_chosen=Construir somente {}
|
||||
arch.aur.sync.several_names.popup.bt_selected=Construir selecionados também
|
||||
arch.building.package=Construindo o pacote {}
|
||||
arch.can_work.not_arch_distro=Somente disponível para distribuições baseadas em ArchLinux
|
||||
arch.checking.conflicts=Verificando se há conflitos com {}
|
||||
arch.checking.deps=Verificando as dependências de {}
|
||||
arch.checking.missing_deps=Verificando dependências ausentes de {}
|
||||
arch.clone=Clonando o repositório {} do AUR
|
||||
arch.category.remove_from_aur=Removido do AUR
|
||||
arch.config.aur=Pacotes do AUR
|
||||
arch.config.aur.tip=Permite gerenciar pacotes dos AUR. git precisa estar instalado.
|
||||
arch.config.aur_rebuild_detector=Verificar necessidade de reinstalação
|
||||
arch.config.aur_rebuild_detector.tip=Verifica se pacotes construídos com versões antigas de bibliotecas precisam ser reconstruídas. Se um pacote precisa ser reconstruído, ele será marcado para atualizar ({} precisa estar instalado).
|
||||
arch.config.aur_rebuild_detector_no_bin=Ignorar binários ({})
|
||||
arch.config.aur_rebuild_detector_no_bin.tip=Se pacotes binários nomeados como "pacote-bin" devem ser ignorados pelo {} ({})
|
||||
arch.config.automatch_providers=Auto-corresponder dependência por nome
|
||||
arch.config.automatch_providers.tip=Associa automaticamente um pacote a uma dependência caso os nomes sejam os mesmos. Caso contrário todos os provedores para a dependência serão exibidos.
|
||||
arch.config.aur_build_dir=Diretório de construção
|
||||
arch.config.aur_build_dir.tip=Define um diretório personalizado onde pacotes do AUR serão construídos. Padrão: {}.
|
||||
arch.config.aur_build_only_chosen=Construir somente escolhido
|
||||
arch.config.aur_build_only_chosen.tip=Alguns pacotes do AUR têm um PKGBUILD comum a outros pacotes e que define a construção para todos. Essa propriedade ativada garantirá que somente o pacote escolhido será construído.
|
||||
arch.config.aur_remove_build_dir=Remover diretório de construção
|
||||
arch.config.aur_remove_build_dir.tip=Se o diretório gerado para a construção de um pacote do AUR deve ser removido após a operação ser finalizada.
|
||||
arch.config.categories_exp=Expiração de categorias
|
||||
arch.config.categories_exp.tip=Define o tempo de expiração (em HORAS) do arquivo de mapeamento de categorias de pacotes armazenado em disco. Utilize 0 para que ele seja sempre atualizado durante a inicialização.
|
||||
arch.config.clean_cache=Remover versões antigas
|
||||
arch.config.clean_cache.tip=Se versões antigas de um pacote armazenadas em disco devem ser removidas durante a desinstalação
|
||||
arch.config.check_dependency_breakage=Verificar quebra de dependência de versão
|
||||
arch.config.check_dependency_breakage.tip=Se durante a verificação dos requisitos de atualização deve-se verificar também versões específicas de dependências. Exemplo: pacote A depende da versão 1.0 de B.
|
||||
arch.config.edit_aur_pkgbuild=Editar PKGBUILD
|
||||
arch.config.edit_aur_pkgbuild.tip=Se o arquivo PKGBUILD de um pacote do AUR deve ser exibido para edição antes da instalação/atualização/reversão
|
||||
arch.config.aur_idx_exp=Expiração do índice
|
||||
arch.config.aur_idx_exp.tip=Define o período (em HORAS) em que o índice do AUR armazenado em disco é considerado atualizado durante a inicialização. Utilize 0 para que ele sempre seja atualizado.
|
||||
arch.config.mirrors_sort_limit=Limite de ordenação de espelhos
|
||||
arch.config.mirrors_sort_limit.tip=Define o número máximo de espelhos que serão utilizados para a ordenação por velocidade. Utilize 0 para não limitar ou deixe em branco para desabilitar a ordenação.
|
||||
arch.config.optimize=Otimizar
|
||||
arch.config.pacman_mthread_download=Download segmentado (repositórios)
|
||||
arch.config.pacman_mthread_download.tip=Se os pacotes dos repositórios devem baixados através de uma ferramenta que trabalha com segmentação/threads (pode ser mais rápido). pacman-mirrors precisa estar instalado.
|
||||
arch.config.prefer_repository_provider=Preferir dependências de repositórios
|
||||
arch.config.prefer_repository_provider.tip=Define automaticamente o pacote único proveniente dos repositórios entre diversos externos ({}) disponíveis como provedor de uma dependência
|
||||
arch.config.refresh_mirrors=Atualizar espelhos ao iniciar
|
||||
arch.config.refresh_mirrors.tip=Atualiza os espelhos de pacotes uma vez ao dia na inicialização
|
||||
arch.config.repos=Pacotes de repositórios
|
||||
arch.config.repos.tip=Permite gerenciar pacotes dos repositórisos
|
||||
arch.config.suggest_optdep_uninstall=Desinstalar dependências opcionais
|
||||
arch.config.suggest_optdep_uninstall.tip=Se as dependências opcionais associadas a pacotes desinstalados devem ser sugeridas para desinstalação. Somente as dependências opcionais que não sejam dependências de outros pacotes serão sugeridas.
|
||||
arch.config.suggest_unneeded_uninstall=Desinstalar dependências desnecessárias
|
||||
arch.config.suggest_unneeded_uninstall.tip=Se as dependências aparentemente não mais necessárias associadas aos pacotes desinstalados devem ser sugeridas para desinstalação. Quando essa proprieda está habilitada automaticamente desabilita a propriedade {}.
|
||||
arch.config.suggestions_exp=Validade de sugestões
|
||||
arch.config.suggestions_exp.tip=Define o período (em horas) no qual as sugestões armazenadas em disco serão consideradas atualizadas. Use 0 se quiser que elas sempre sejam atualizadas.
|
||||
arch.config.sync_dbs=Sincronizar bases de pacotes
|
||||
arch.config.sync_dbs.tip=Sincroniza as bases de pacotes uma vez ao dia antes da primeira instalação, atualização ou reversão de pacote. Essa opção ajuda a evitar erros durante essa operações.
|
||||
arch.config.sync_dbs_start.tip=Sincroniza as bases de pacotes durante a inicialização uma vez ao dia
|
||||
arch.custom_action.clean_cache=Limpar cache
|
||||
arch.custom_action.clean_cache.desc=Remove todo os arquivos de pacotes baixados do cache em disco
|
||||
arch.custom_action.clean_cache.fail=Ocorreu um problema durante a limpeza do cache
|
||||
arch.custom_action.clean_cache.msg1=Cache é um diretório no sistema onde ficam armazenados arquivos de versões antigas de alguns pacotes
|
||||
arch.custom_action.clean_cache.msg2=Limpá-lo aumenta o espaço de armazenamento disponível sem prejudicar o seu sistema
|
||||
arch.custom_action.clean_cache.msg3=Também auxilia quando há pacotes baixados com problemas de integridade que estão impossibilitando uma ação
|
||||
arch.custom_action.clean_cache.no_dir=O diretório de cache {} não existe
|
||||
arch.custom_action.clean_cache.status=Limpando cache
|
||||
arch.custom_action.clean_cache.success=Cache foi limpo com sucesso !
|
||||
arch.custom_action.refresh_dbs=Sincronizar bases de pacotes
|
||||
arch.custom_action.refresh_dbs.desc=Sincroniza os pacotes disponíveis nos repositórios
|
||||
arch.custom_action.refresh_dbs.failed=Não foi possível sincronizar as bases de pacotes
|
||||
arch.custom_action.refresh_mirrors=Atualizar espelhos
|
||||
arch.custom_action.refresh_mirrors.desc=Permite escolher os espelhos de repositórios e ordená-los pelo mais rápido
|
||||
arch.custom_action.refresh_mirrors.failed=Não foi possível atualizar os espelhos
|
||||
arch.custom_action.refresh_mirrors.location.all=Todas
|
||||
arch.custom_action.refresh_mirrors.location.all.tip=Se essa opção estiver marcada, as demais serão ignoradas.
|
||||
arch.custom_action.refresh_mirrors.select_label=Marque as localizações desejadas
|
||||
arch.custom_action.refresh_mirrors.status.sorting=Ordenando os espelhos por velocidade
|
||||
arch.custom_action.refresh_mirrors.status.updating=Atualizando espelhos
|
||||
arch.custom_action.setup_snapd=Verificar suporte ao Snaps
|
||||
arch.custom_action.setup_snapd.desc=Verifica se o suporte a Snaps está devidamente habilitado no sistema
|
||||
snap.custom_action.setup_snapd.missing_link=Criar o link {} para {}
|
||||
arch.custom_action.setup_snapd.status=Verificando suporte aos Snaps
|
||||
snap.custom_action.setup_snapd.ready=Pronto!
|
||||
snap.custom_action.setup_snapd.ready.body=O sistema está pronto para trabalhar com Snaps!
|
||||
snap.custom_action.setup_snapd.required_actions=Ações necessárias para que os Snaps funcionem corretamente
|
||||
snap.custom_action.setup_snapd.service_disabled=Habilitar o serviço {}
|
||||
snap.custom_action.setup_snapd.service_inactive=Iniciar o serviço {}
|
||||
arch.custom_action.upgrade_system=Atualização rápida de sistema
|
||||
arch.custom_action.upgrade_system.desc=Tenta atualizar o sistema através de uma chamada única para o pacman
|
||||
arch.custom_action.upgrade_system.no_updates=Não há atualizações disponíveis
|
||||
arch.custom_action.upgrade_system.pkgs=Os pacotes abaixo serão atualizados
|
||||
arch.custom_action.upgrade_system.status=Atualizando sistema
|
||||
arch.custom_action.upgrade_system.substatus=Atualizando pacotes
|
||||
arch.custom_action.upgrade_system.success.line1=Sistema atualizado com sucesso !
|
||||
arch.custom_action.upgrade_system.success.line2=Algumas mudanças podem exigir a reinicialização do sistem para que surtam efeito.
|
||||
arch.custom_action.upgrade_system.success.line3=Reiniciar agora ?
|
||||
arch.dialog.providers.line1=Existem multiplos provedores para algumas das dependências
|
||||
arch.dialog.providers.line2=Selecione os desejados
|
||||
arch.downgrade.error=Erro
|
||||
arch.downgrade.impossible=Não é possível reverter a versão de {}
|
||||
arch.downgrade.install_older=Instalando versão anterior
|
||||
arch.downgrade.reading_commits=Lendo os commits do repositório
|
||||
arch.downgrade.repo_pkg.no_versions=Nenhuma versão antiga encontrada no disco
|
||||
arch.downgrade.searching_stored=Procurando versões antigas no disco
|
||||
arch.downgrade.version_found=Versão atual do pacote encontrada
|
||||
arch.aur.error.missing_root_dep={dep} não está instalado e é necessário para a instalação de pacotes do {aur} como o usuário {root}
|
||||
arch.aur.error.add_builder_user=Não foi possível criar o usuário {user} para a construção de pacotes do {aur}
|
||||
arch.info.00_pkg_build=pkgbuild
|
||||
arch.info.00_url=URL
|
||||
arch.info.01_id=id
|
||||
arch.info.02_name=nome
|
||||
arch.info.03_description=descrição
|
||||
arch.info.03_version=versão
|
||||
arch.info.04_exec=Executável
|
||||
arch.info.04_orphan=órfão
|
||||
arch.info.04_orphan.true=sim
|
||||
arch.info.04_orphan.false=não
|
||||
arch.info.04_out_of_date=desatualizado
|
||||
arch.info.04_out_of_date.true=sim
|
||||
arch.info.04_out_of_date.false=não
|
||||
arch.info.04_popularity=popularidade
|
||||
arch.info.05_votes=votos
|
||||
arch.info.06_package_base=pacote base
|
||||
arch.info.07_maintainer=mantenedor
|
||||
arch.info.08_first_submitted=primeira submissão
|
||||
arch.info.09_last_modified=última modificação
|
||||
arch.info.10_url=url para baixar
|
||||
arch.info.11_pkg_build_url=url pkgbuild
|
||||
arch.info.12_makedepends=dependências de compilação
|
||||
arch.info.13_dependson=dependências de instalação
|
||||
arch.info.13_pkg_build=pkgbuild
|
||||
arch.info.14_installed_files=arquivos instalados
|
||||
arch.info.14_optdepends=dependências opcionais
|
||||
arch.info.15_checkdepends=dependências de verificação
|
||||
arch.info.arch=arquitetura
|
||||
arch.info.arch.any=qualquer
|
||||
arch.info.architecture=arquitetura
|
||||
arch.info.architecture.any=qualquer
|
||||
arch.info.build date=data de construção
|
||||
arch.info.conflicts with=conflita com
|
||||
arch.info.depends=depende
|
||||
arch.info.depends on=depende de
|
||||
arch.info.description=descrição
|
||||
arch.info.download size=Tamanho do arquivo (download)
|
||||
arch.info.install date=data de instalação
|
||||
arch.info.install reason=razão da instalação
|
||||
arch.info.install reason.explicitly installed=instalado explicitamente
|
||||
arch.info.install reason.installed as a dependency for another package=dependência de outro pacote
|
||||
arch.info.install script=script de instalação
|
||||
arch.info.install script.no=nenhum
|
||||
arch.info.installed files=arquivos instalados
|
||||
arch.info.installed size=tamanho da instalação
|
||||
arch.info.last_modified=última modificação
|
||||
arch.info.license=licença
|
||||
arch.info.licenses=licenças
|
||||
arch.info.licenses.custom=personalizada
|
||||
arch.info.name=nome
|
||||
arch.info.optdepends=dependências opcionais
|
||||
arch.info.optional deps=dependências opcionais
|
||||
arch.info.optional for=opcional para
|
||||
arch.info.options=opções
|
||||
arch.info.packager=empacotador
|
||||
arch.info.packager.unknown packager=desconhecido
|
||||
arch.info.pkgdesc=descrição
|
||||
arch.info.pkgname=nome
|
||||
arch.info.pkgrel=lançamento
|
||||
arch.info.pkgver=versão
|
||||
arch.info.provides=provê
|
||||
arch.info.replaces=substitui
|
||||
arch.info.required by=requerido por
|
||||
arch.info.source=origem
|
||||
arch.info.url=url
|
||||
arch.info.validated by=validador por
|
||||
arch.info.validated by.signature=assinatura
|
||||
arch.info.validpgpkeys=Chaves PGP válidas
|
||||
arch.info.version=versão
|
||||
arch.install.aur.root_error.body=Não é permitido instalar, atualizar ou reverter a versão de um pacote como usuário root
|
||||
arch.install.aur.root_error.title=Ação não permitida
|
||||
arch.install.aur.unknown_key.body=Para continuar a instalação de {} é ncessário confiar na seguinte chave pública {}
|
||||
arch.install.aur.unknown_key.title=Chave pública necessária
|
||||
arch.install.conflict.popup.body=Os aplicativos {} estão em conflito. Você precisa desinstalar um para instalar o outro. Continuar ?
|
||||
arch.install.conflict.popup.title=Conflito detectado
|
||||
arch.install.dep_not_found.body.l1=A dependência {dep}{source} não foi encontrado no AUR nem nos repositórios.
|
||||
arch.install.dep_not_found.body.l2=Pode ser um problema de sincronização das bases de pacotes.
|
||||
arch.install.dep_not_found.body.l3=Operação cancelada.
|
||||
arch.install.dep_not_found.title=Dependência não encontrada
|
||||
arch.install.dependency.install=Instalando o pacote dependente {}
|
||||
arch.install.dependency.install.error=Não foi possível instalar os pacotes dependentes: {}. Instalação de {} abortada.
|
||||
arch.install.error.conflicting_files=O pacote {} quer sobrepor alguns arquivos de outros pacotes instalados
|
||||
arch.install.error.conflicting_files.proceed=Permitir
|
||||
arch.install.error.conflicting_files.stop=Cancelar instalação
|
||||
arch.install.optdep.error=Não foi possível instalar os pacotes opcionais: {}
|
||||
arch.install.optdeps.request.body=Selecione abaixo os pacotes opcionais associados que você queira instalar
|
||||
arch.install.optdeps.request.success={pkg} foi instalado com sucesso !
|
||||
arch.install.optdeps.request.title=Dependências opcionais
|
||||
arch.installing.package=Instalando o pacote {}
|
||||
arch.checking_unnecessary_deps=Verificando se há pacotes não mais necessários
|
||||
arch.makepkg.optimizing=Otimizando a compilação
|
||||
arch.missing_deps.body=As seguintes dependências ({deps}) serão instaladas
|
||||
arch.missing_deps.title=Dependências ausentes
|
||||
arch.missing_deps_found=Dependencias ausentes para {}
|
||||
arch.mthread_downloaded.error.cache_dir=Não foi possível criar o diretório para cache {}
|
||||
arch.mthread_downloaded.error.cancelled=Operação cancelada
|
||||
arch.optdeps.checking=Verificando as dependências opcionais de {}
|
||||
arch.package.requires_rebuild=Precisa ser reinstalado
|
||||
arch.providers=provedores
|
||||
arch.substatus.conflicts=Verificando conflitos
|
||||
arch.substatus.disk_space=Verificando espaço disponível em disco
|
||||
arch.substatus.integrity=Verificando a integridade dos pacotes
|
||||
arch.substatus.keyring=Verificando o keyring
|
||||
arch.substatus.loading_files=Carregando os arquivos dos pacotes
|
||||
arch.substatus.pre_hooks=Executando ganchos pré-transação
|
||||
arch.substatus.retrieve_pkgs=Obtendo pacotes
|
||||
arch.sync.dep_breakage.reason={} precisa de {}
|
||||
arch.sync_databases.substatus=Sincronizando bases de pacotes
|
||||
arch.sync_databases.substatus.error=Não foi possível sincronizar as bases de pacotes
|
||||
arch.sync_databases.substatus.synchronized=Sincronizado
|
||||
arch.task.aur.index.status=Gerando índice local do AUR
|
||||
arch.task.aur.index.substatus.checking=Checando atualizações
|
||||
arch.task.aur.index.substatus.download=Baixando o índice
|
||||
arch.task.aur.index.substatus.error.download=Erro de conexão ao baixar o índice
|
||||
arch.task.aur.index.substatus.error.no_data=Error: índice vazio
|
||||
arch.task.aur.index.substatus.gen_index=Gerando índice
|
||||
arch.task.checking_settings=Verificando configurações
|
||||
arch.task.disabled=Desabilitado
|
||||
arch.task.disk_cache=Indexando dados de pacotes
|
||||
arch.task.disk_cache.checking=Verificando índice
|
||||
arch.task.disk_cache.indexed=Indexados
|
||||
arch.task.disk_cache.indexing=Indexando
|
||||
arch.task.disk_cache.reading_files=Lendo arquivos
|
||||
arch.task.disk_cache.waiting_aur_index=Aguardando {}
|
||||
arch.task.mirrors=Atualizando espelhos
|
||||
arch.task.mirrors.cached=Atualizados
|
||||
arch.task.optimizing=Otimizando {}
|
||||
arch.task.sync_sb.status=Atualizando {}
|
||||
arch.uninstall.clean_cached.error=Não foi possível remover versões antigas de {} encontradas em disco
|
||||
arch.uninstall.clean_cached.substatus=Removendo versões antigas do disco
|
||||
arch.uninstall.error.hard_dep_in_hold=Não é possível desinstalar {} pois uma de suas dependências está bloqueada (InHold)
|
||||
arch.uninstall.required_by=Os pacotes ({no}) abaixo dependem de {pkgs} para funcionar corretamente
|
||||
arch.uninstall.required_by.warn=Para prosseguir será necessário desinstá-los também
|
||||
arch.uninstall.unnecessary.all=Os seguintes {} pacotes serão desinstalados
|
||||
arch.uninstall.unnecessary.cancel=Manter
|
||||
arch.uninstall.unnecessary.l1=Pacotes desinstalados com sucesso!
|
||||
arch.uninstall.unnecessary.l2=Os pacotes abaixo parecem não ser mais necessários
|
||||
arch.uninstall.unnecessary.proceed=Desinstalar
|
||||
arch.uninstalling.conflict=Desinstalando pacotes conflitante
|
||||
arch.uninstalling.conflict.fail=Não foi possível desinstalar os pacotes conflitantes: {}
|
||||
arch.update.disabled.tooltip=Este pacote só pode ser atualizado através da ação "Atualização rápida de sistema"
|
||||
arch.update_summary.conflict_between=Conflito entre {} e {}
|
||||
arch.update_summary.to_install.dep_conflict=Conflito entre as dependências {} e {}
|
||||
arch.update_summary.to_update.conflicts_dep=Conflita com a dependência {} de {}
|
||||
arch.update_summary.to_update.dep_conflicts=A dependência {} conflita com {}
|
||||
arch.upgrade.caching_pkgs_data=Armazenando dados das atualizações
|
||||
arch.upgrade.error.conflicting_files=Alguns dos pacotes que estão sendo atualizados querem sobrepor arquivos de outros pacotes instalados
|
||||
arch.upgrade.error.dep_breakage=Foram detectados os seguintes probemas de quebra de dependência
|
||||
arch.upgrade.error.dep_breakage.item=A nova versão de {} quebra a dependência {} requerida pela versão instalada de {}
|
||||
arch.upgrade.error.dep_breakage.proceed=Continuar mesmo assim
|
||||
arch.upgrade.error.dep_breakage.stop=Cancelar atualização
|
||||
arch.upgrade.conflicting_files.proceed=Permitir e continuar
|
||||
arch.upgrade.conflicting_files.stop=Cancelar atualização
|
||||
arch.upgrade.fail=Atualização do pacote {} falhou
|
||||
arch.upgrade.mthreaddownload.fail=Não foi possível baixar todos os pacotes para atualizar
|
||||
arch.upgrade.success=Pacote {} atualizado com sucesso
|
||||
arch.upgrade.upgrade_aur_pkgs=Atualizando pacotes do AUR
|
||||
arch.upgrade.upgrade_repo_pkgs=Atualizando pacotes dos repositórios
|
||||
arch.warning.disabled={} parece não estar instalado. Não será possível gerenciar pacotes Arch / AUR.
|
||||
arch.warning.aur_missing_dep={} parece não estar instalado. Não será possível gerenciar pacotes do AUR.
|
||||
arch_repo.history.1_version=versão
|
||||
arch_repo.history.2_release=lançamento
|
||||
arch_repo.history.3_date=data
|
||||
aur.history.1_version=versão
|
||||
aur.history.2_release=lançamento
|
||||
aur.history.3_date=data
|
||||
category.orphan=órfão
|
||||
category.out_of_date=desatualizado
|
||||
gem.arch.info=Pacotes de software disponíveis para distribuições baseadas em Arch Linux
|
||||
gem.arch.label=Arch
|
||||
gem.arch.type.arch_repo.label=Arch - Repositório
|
||||
gem.arch.type.aur.label=Arch - AUR
|
||||
@@ -1,316 +0,0 @@
|
||||
arch.action.rebuild_check.allow=Разрешить проверку переустановки
|
||||
arch.action.rebuild_check.allow.desc=Позволяет проверить необходимость переустановки пакета
|
||||
arch.action.rebuild_check.allow.status=Проверка возможности переустановки
|
||||
arch.action.rebuild_check.allow.confirm=Разрешить проверку переустановки для {} ?
|
||||
arch.action.rebuild_check.ignore=Игнорирование проверки переустановки
|
||||
arch.action.rebuild_check.ignore.desc=Не проверять, требуется ли переустановка пакета в системе
|
||||
arch.action.rebuild_check.ignore.status=Игнорирование проверки переустановки
|
||||
arch.action.rebuild_check.ignore.confirm=Игнорировать проверку переустановки для {} ?
|
||||
arch.action.db_locked.body.l1=База данных системных пакетов заблокирована.
|
||||
arch.action.db_locked.body.l2=Для продолжения работы необходимо её разблокировать.
|
||||
arch.action.db_locked.confirmation=Разблокировать и продолжить
|
||||
arch.action.db_locked.error=Разблокировать базу данных не удалось.
|
||||
arch.action.db_locked.title=База данных заблокирована
|
||||
arch.action.disable_pkgbuild_edition=Отметить PKGBUILD из {} как редактируемый ?
|
||||
arch.action.disable_pkgbuild_edition.confirm=Снять пометку PKGBUILD из {} как редактируемую ?
|
||||
arch.action.disable_pkgbuild_edition.desc=Не допускает редактирования файла PKGBUILD пакета перед его обновлением
|
||||
arch.action.disable_pkgbuild_edition.status=Пометка PKGBUILD как редактируемый
|
||||
arch.action.enable_pkgbuild_edition=Пометить PKGBUILD как доступный для редактирования
|
||||
arch.action.enable_pkgbuild_edition.confirm=Пометить PKGBUILD из {} как редактируемый ?
|
||||
arch.action.enable_pkgbuild_edition.desc=Позволяет редактировать файл PKGBUILD пакета перед его обновлением
|
||||
arch.action.enable_pkgbuild_edition.status=Пометить PKGBUILD как редактируемый
|
||||
arch.action.reinstall=Переустановить
|
||||
arch.action.reinstall.desc=Повторная попытка установки пакета
|
||||
arch.action.reinstall.status=Переустановка
|
||||
arch.action.reinstall.confirm=Хотите ли вы переустановить {}?
|
||||
arch.action.reinstall.error.no_apidata=Не удалось получить информацию о {} из AUR
|
||||
arch.aur.action.edit_pkgbuild.body=Отредактировать файл PKGBUILD из {} перед продолжением ?
|
||||
arch.aur.install.pgp.body=Для установки {} необходимо получить следующие PGP ключи
|
||||
arch.aur.install.pgp.receive_fail=Не удалось получить PGP-ключ {}
|
||||
arch.aur.install.pgp.sign_fail=Не удалось подписать PGP-ключ {}
|
||||
arch.aur.install.pgp.substatus=Получение PGP-ключа {}
|
||||
arch.aur.install.pgp.success=Ключи PGP получены и подписаны
|
||||
arch.aur.install.pgp.title=Требуются ключи PGP
|
||||
arch.aur.install.unknown_key.receive_error=Не удалось получить открытый ключ {}
|
||||
arch.aur.install.unknown_key.status=Получение открытого ключа {}
|
||||
arch.aur.install.validity_check.body=Некоторые исходные файлы, необходимые для установки {}, не работают. Установка будет отменена, чтобы предотвратить повреждение вашей системы.
|
||||
arch.aur.install.validity_check.proceed=Вы всё равно хотите продолжить ? ( не рекомендуется )
|
||||
arch.aur.install.validity_check.title=Проблемы целостности
|
||||
arch.aur.install.verifying_pgp=Проверка ключей PGP
|
||||
arch.aur.build.list_output=Проверка собранных файлов
|
||||
arch.aur.sync.several_names.popup.body=Файл определения (PKGBUILD) пакета {} настраивает сборку других пакетов
|
||||
arch.aur.sync.several_names.popup.bt_only_chosen=Собирать только {}
|
||||
arch.aur.sync.several_names.popup.bt_selected=Сборка выбранных тоже
|
||||
arch.building.package=Сборка пакета {}
|
||||
arch.can_work.not_arch_distro=Доступно только для дистрибутивов на базе ArchLinux
|
||||
arch.checking.conflicts=Проверка конфликтов с {}
|
||||
arch.checking.deps=Проверка зависимостей {}
|
||||
arch.checking.missing_deps=Проверка отсутствующих зависимостей {}
|
||||
arch.clone=Клонирование AUR-репозитория {}
|
||||
arch.category.remove_from_aur=Удален из AUR
|
||||
arch.config.aur=Пакеты AUR
|
||||
arch.config.aur.tip=Это позволяет управлять пакетами AUR. Git должен быть установлен.
|
||||
arch.config.aur_rebuild_detector=Проверка необходимости переустановки
|
||||
arch.config.aur_rebuild_detector.tip=Проверяет, нужно ли перестраивать пакеты, собранные с использованием старых версий библиотек. Если пакет нуждается в перестройке, он будет помечен для обновления ({} должен быть установлен)
|
||||
arch.config.aur_rebuild_detector_no_bin=Игнорировать двоичные файлы ({})
|
||||
arch.config.aur_rebuild_detector_no_bin.tip=Должны ли двоичные пакеты с именем "package-bin" игнорироваться {} ({})
|
||||
arch.config.automatch_providers=Автоматическое сопоставление зависимостей по имени
|
||||
arch.config.automatch_providers.tip=Aвтоматически связывает пакет с зависимостью, если оба имени совпадают. В противном случае будут отображены все пакеты для данной зависимости.
|
||||
arch.config.aur_build_dir=Каталог сборки
|
||||
arch.config.aur_build_dir.tip=Определяет пользовательский каталог, в который будут собираться пакеты AUR. По умолчанию: {}.
|
||||
arch.config.aur_build_only_chosen=Собирать только выбранные
|
||||
arch.config.aur_build_only_chosen.tip=Некоторые пакеты AUR имеют общий PKGBUILD, разделяемый с другими пакетами и определяющий инструкции по сборке для каждого из них. Включение этого свойства гарантирует, что будет собран только выбранный пакет.
|
||||
arch.config.aur_remove_build_dir=Удалить каталог сборки
|
||||
arch.config.aur_remove_build_dir.tip=Должен ли созданный каталог сборки пакета быть удален после завершения операций.
|
||||
arch.config.categories_exp=Срок действия категорий
|
||||
arch.config.categories_exp.tip=Определяет время действия (в часах) файла отображения категорий пакетов, хранящегося на диске. Используйте 0, чтобы он всегда обновлялся при инициализации.
|
||||
arch.config.clean_cache=Удаление старых версий
|
||||
arch.config.clean_cache.tip=Следует ли удалять старые версии пакета, хранящиеся на диске, при деинсталляции
|
||||
arch.config.check_dependency_breakage=Проверять нарушение версий зависимостей
|
||||
arch.config.check_dependency_breakage.tip=Нужно ли при проверке требований к обновлению необходимо проверять и конкретные версии зависимостей. Пример: пакет А зависит от версии 1.0 пакета Б.
|
||||
arch.config.edit_aur_pkgbuild=Редактирование PKGBUILD
|
||||
arch.config.edit_aur_pkgbuild.tip=Должен ли файл PKGBUILD пакета AUR отображаться для редактирования перед его установкой/модернизацией/даунгрейдом
|
||||
arch.config.aur_idx_exp=Срок действия индекса
|
||||
arch.config.aur_idx_exp.tip=Определяет период (в часах), в течение которого индекс AUR, хранящийся на диске, будет считаться актуальным в процессе инициализации. Используйте 0, чтобы он всегда обновлялся.
|
||||
arch.config.mirrors_sort_limit=Ограничение сортировки зеркал
|
||||
arch.config.mirrors_sort_limit.tip=Определяет максимальное количество зеркал, которые будут использоваться для скоростной сортировки. Используйте 0 для отсутствия ограничений или оставьте это значение пустым, чтобы отключить сортировку.
|
||||
arch.config.optimize=Оптимизация
|
||||
arch.config.optimize.tip=Оптимизированные настройки будут использоваться для ускорения установки пакетов, в противном случае будут использоваться системные настройки
|
||||
arch.config.pacman_mthread_download=Многопоточная загрузка (репозитории)
|
||||
arch.config.pacman_mthread_download.tip=Следует ли загружать пакеты репозитория с помощью инструмента, который работает с потоками (это может быть быстрее). Должен быть установлен pacman-mirrors.
|
||||
arch.config.prefer_repository_provider=Предпочтительные зависимости репозитория
|
||||
arch.config.prefer_repository_provider.tip=Автоматически выбирает одиного провайдера из репозиториев среди нескольких внешних ({}), доступных в качестве поставщика для заданной зависимости
|
||||
arch.config.refresh_mirrors=Обновить зеркала при запуске
|
||||
arch.config.refresh_mirrors.tip=Обновляйте зеркала пакета один раз в день при запуске
|
||||
arch.config.repos=Пакеты репозиториев
|
||||
arch.config.repos.tip=Он позволяет управлять пакетами из набора репозиториев
|
||||
arch.config.suggest_optdep_uninstall=Удаление необязательных зависимостей
|
||||
arch.config.suggest_optdep_uninstall.tip=Должны ли необязательные зависимости, связанные с удаленными пакетами, быть предложены для удаления. Будут предложены только те дополнительные зависимости, которые не являются зависимостями других пакетов.
|
||||
arch.config.suggest_unneeded_uninstall=Удаление ненужных зависимостей
|
||||
arch.config.suggest_unneeded_uninstall.tip=Должны ли зависимости, явно не нужные, связанные с удаляемыми пакетами, быть предложены к удалению. При включении этого свойства автоматически отключается свойство {}.
|
||||
arch.config.suggestions_exp=Срок действия предложений
|
||||
arch.config.suggestions_exp.tip=Определяет период (в часах), в течение которого предложения, хранящиеся на диске, будут считаться актуальными. Используйте 0, если вы хотите обновлять их всегда.
|
||||
arch.config.sync_dbs=Синхронизация баз данных пакетов
|
||||
arch.config.sync_dbs.tip=Синхронизируйте базы данных пакетов один раз в день перед первой установкой, обновлением или понижением версии пакета. Этот параметр помогает предотвратить ошибки во время этих операций.
|
||||
arch.config.sync_dbs_start.tip=Синхронизирует базы данных пакетов во время инициализации один раз в день
|
||||
arch.custom_action.clean_cache=Очистка кэша
|
||||
arch.custom_action.clean_cache.desc=Удаляет из дискового кэша все загруженные файлы пакетов
|
||||
arch.custom_action.clean_cache.fail=При очистке кэша произошла ошибка
|
||||
arch.custom_action.clean_cache.msg1=Кэш - это системный каталог, в котором хранятся файлы старых версий пакетов
|
||||
arch.custom_action.clean_cache.msg2=Очистка освобождает место в памяти без вреда для системы
|
||||
arch.custom_action.clean_cache.msg3=Это также помогает при наличии загруженных пакетов с проблемами целостности, блокирующих выполнение действия
|
||||
arch.custom_action.clean_cache.no_dir=Каталог кэша {} не существует
|
||||
arch.custom_action.clean_cache.status=Очистка кэша
|
||||
arch.custom_action.clean_cache.success=Кэш успешно очищен !
|
||||
arch.custom_action.refresh_dbs=Синхронизация баз данных пакетов
|
||||
arch.custom_action.refresh_dbs.desc=Синхронизация доступных пакетов в репозиториях
|
||||
arch.custom_action.refresh_dbs.failed=Синхронизировать базу данных пакета не удалось
|
||||
arch.custom_action.refresh_mirrors=Обновить список зеркал
|
||||
arch.custom_action.refresh_mirrors.desc=Позволяет выбирать зеркала репозиториев и сортировать их по скорости работы
|
||||
arch.custom_action.refresh_mirrors.failed=Обновить зеркала не удалось
|
||||
arch.custom_action.refresh_mirrors.location.all=Все
|
||||
arch.custom_action.refresh_mirrors.location.all.tip=Если этот параметр установлен, остальные будут проигнорированы.
|
||||
arch.custom_action.refresh_mirrors.select_label=Проверка предпочитаемых расположений
|
||||
arch.custom_action.refresh_mirrors.status.sorting=Сортировка зеркал по скорости
|
||||
arch.custom_action.refresh_mirrors.status.updating=Обновление зеркал
|
||||
arch.custom_action.setup_snapd=Проверка поддержки Snaps
|
||||
arch.custom_action.setup_snapd.desc=Проверяет, правильно ли включена поддержка Snaps в системе
|
||||
snap.custom_action.setup_snapd.missing_link=Создать ссылку {} для {}
|
||||
arch.custom_action.setup_snapd.status=Проверка поддержки Snaps
|
||||
snap.custom_action.setup_snapd.ready=Готово!
|
||||
snap.custom_action.setup_snapd.ready.body=Система готова к работе со Snaps!
|
||||
snap.custom_action.setup_snapd.required_actions=Действия, необходимые для корректной работы Snaps
|
||||
snap.custom_action.setup_snapd.service_disabled=Включить службу {}
|
||||
snap.custom_action.setup_snapd.service_inactive=Запуск сервиса {}
|
||||
arch.custom_action.upgrade_system=Обновление системы
|
||||
arch.custom_action.upgrade_system.desc=Попытка обновления системы с помощью разового вызова pacman
|
||||
arch.custom_action.upgrade_system.no_updates=Обновления отсутствуют
|
||||
arch.custom_action.upgrade_system.pkgs=Следующие пакеты будут обновлены
|
||||
arch.custom_action.upgrade_system.status=Система обновлена
|
||||
arch.custom_action.upgrade_system.substatus=Обновление пакетов
|
||||
arch.custom_action.upgrade_system.success.line1=Система успешно обновлена!
|
||||
arch.custom_action.upgrade_system.success.line2=Для вступления в силу некоторых изменений может потребоваться перезагрузка системы.
|
||||
arch.custom_action.upgrade_system.success.line3=Перезагрузить сейчас ?
|
||||
arch.dialog.providers.line1=Для некоторых зависимостей существует несколько провайдеров
|
||||
arch.dialog.providers.line2=Выберите необходимые
|
||||
arch.downgrade.error=Ошибка
|
||||
arch.downgrade.impossible=Невозможно понизить версию {}
|
||||
arch.downgrade.install_older=Установка старой версии
|
||||
arch.downgrade.reading_commits=Чтение коммитов репозитория
|
||||
arch.downgrade.repo_pkg.no_versions=Старая версия на диске не найдена
|
||||
arch.downgrade.searching_stored=Поиск старых версий на диске
|
||||
arch.downgrade.version_found=Найдена текущая версия пакета
|
||||
arch.aur.error.missing_root_dep={dep} не установлен и необходим для установки пакетов {aur} от имени пользователя {root}
|
||||
arch.aur.error.add_builder_user=Не удалось создать пользователя {user} для сборки пакетов {aur}.
|
||||
arch.info.00_pkg_build=PKGBUILD
|
||||
arch.info.00_url=URL
|
||||
arch.info.01_id=Идентификатор
|
||||
arch.info.02_name=Имя
|
||||
arch.info.03_description=Описание
|
||||
arch.info.03_version=Версия
|
||||
arch.info.04_exec=Исполняемый файл
|
||||
arch.info.04_orphan=Пакет-сирота
|
||||
arch.info.04_orphan.true=да
|
||||
arch.info.04_orphan.false=нет
|
||||
arch.info.04_out_of_date=устаревший
|
||||
arch.info.04_out_of_date.true=да
|
||||
arch.info.04_out_of_date.false=нет
|
||||
arch.info.04_popularity=Популярность
|
||||
arch.info.05_votes=Голоса
|
||||
arch.info.06_package_base=Базовый пакет
|
||||
arch.info.07_maintainer=Сопровождающий
|
||||
arch.info.08_first_submitted=Впервые представлен
|
||||
arch.info.09_last_modified=Последнее изменение
|
||||
arch.info.10_url=Страница загрузки
|
||||
arch.info.11_pkg_build_url=Страница PKGBUILD
|
||||
arch.info.12_makedepends=Зависимости компиляции
|
||||
arch.info.13_dependson=Зависимости установки
|
||||
arch.info.13_pkg_build=PKGBUILD
|
||||
arch.info.14_installed_files=Устанавливаемые файлы
|
||||
arch.info.14_optdepends=Необязательные зависимости
|
||||
arch.info.15_checkdepends=Проверка зависимостей
|
||||
arch.info.arch=Архитектура
|
||||
arch.info.arch.any=Несколько
|
||||
arch.info.architecture=Архитектура
|
||||
arch.info.architecture.any=Несколько
|
||||
arch.info.build date=Дата сборки
|
||||
arch.info.conflicts with=Конфликты с
|
||||
arch.info.depends=Зависимости
|
||||
arch.info.depends on=Зависит от
|
||||
arch.info.description=Описание
|
||||
arch.info.download size=Размер загрузки
|
||||
arch.info.install date=Дата установки
|
||||
arch.info.install reason=Причина установки
|
||||
arch.info.install reason.explicitly installed=установлен явно
|
||||
arch.info.install reason.installed as a dependency for another package=зависимость от другого пакета
|
||||
arch.info.install script=Скрипт установки
|
||||
arch.info.install script.no=Нет
|
||||
arch.info.installed files=установленные файлы
|
||||
arch.info.installed size=Размер установки
|
||||
arch.info.last_modified=Последнее изменение
|
||||
arch.info.license=Лицензия
|
||||
arch.info.licenses=Лицензии
|
||||
arch.info.licenses.custom=Пользовательское
|
||||
arch.info.name=Имя
|
||||
arch.info.optdepends=Необязательные зависимости
|
||||
arch.info.optional deps=Необязательные зависимости
|
||||
arch.info.optional for=необязательно для
|
||||
arch.info.options=Опции
|
||||
arch.info.packager=Упаковщик
|
||||
arch.info.packager.unknown packager=Неизвестно
|
||||
arch.info.pkgdesc=Описание
|
||||
arch.info.pkgname=Имя
|
||||
arch.info.pkgrel=Релиз
|
||||
arch.info.pkgver=Версия
|
||||
arch.info.provides=Поставщик
|
||||
arch.info.replaces=Заменяет
|
||||
arch.info.required by=требуется
|
||||
arch.info.source=Источник
|
||||
arch.info.url=Страница
|
||||
arch.info.validated by=подтверждено
|
||||
arch.info.validated by.signature=подпись
|
||||
arch.info.validpgpkeys=Действительные PGP-ключи
|
||||
arch.info.version=Версия
|
||||
arch.install.aur.root_error.body=Не разрешается устанавливать, обновлять или понижать версию пакета от имени пользователя root
|
||||
arch.install.aur.root_error.title=Недопустимое действие
|
||||
arch.install.aur.unknown_key.body=Для продолжения установки {} необходимо довериться следующему открытому ключу {}
|
||||
arch.install.aur.unknown_key.title=Требуется открытый ключ
|
||||
arch.install.conflict.popup.body=Приложения {} находятся в конфликте. Вы должны удалить одно, чтобы установить другоое. Продолжить ?
|
||||
arch.install.conflict.popup.title=Обнаружен конфликт
|
||||
arch.install.dep_not_found.body.l1=Требуемая зависимость {dep}{source} не была найдена ни в AUR, ни в зеркалах по умолчанию.
|
||||
arch.install.dep_not_found.body.l2=Возможно, это проблема синхронизации базы данных пакета.
|
||||
arch.install.dep_not_found.body.l3=Операция отменена.
|
||||
arch.install.dep_not_found.title=Зависимость не найдена
|
||||
arch.install.dependency.install=Установка зависимостей пакета {}
|
||||
arch.install.dependency.install.error=Не удалось установить зависимые пакеты: {}. Установка {} прервана.
|
||||
arch.install.error.conflicting_files=Пакет {} хочет перезаписать файлы из других установленных пакетов
|
||||
arch.install.error.conflicting_files.proceed=Разрешить
|
||||
arch.install.error.conflicting_files.stop=Отмена установки
|
||||
arch.install.optdep.error=Не удалось установить дополнительные пакеты: {}
|
||||
arch.install.optdeps.request.body=Проверка дополнительных пакетов, которые необходимо установить
|
||||
arch.install.optdeps.request.success={pkg} был успешно установлен !
|
||||
arch.install.optdeps.request.title=Необязательные зависимости
|
||||
arch.installing.package=Установка пакета {}
|
||||
arch.checking_unnecessary_deps=Проверка наличия пакетов, которые больше не нужны
|
||||
arch.makepkg.optimizing=Оптимизация компиляции
|
||||
arch.missing_deps.body=Будут установлены следующие зависимости ({deps})
|
||||
arch.missing_deps.title=Отсутствующие зависимости
|
||||
arch.missing_deps_found=Отсутствуют зависимости для {}
|
||||
arch.mthread_downloaded.error.cache_dir=Не удалось создать каталог кэша {}
|
||||
arch.mthread_downloaded.error.cancelled=Операция отменена
|
||||
arch.optdeps.checking=Проверка необязательных обязательных зависимостей {}
|
||||
arch.package.requires_rebuild=Требуется переустановка
|
||||
arch.providers=провайдеры
|
||||
arch.substatus.conflicts=Проверка на наличие конфликтов
|
||||
arch.substatus.disk_space=Проверка доступного дискового пространства
|
||||
arch.substatus.integrity=Проверка целостности пакетов
|
||||
arch.substatus.keyring=Проверка keyring
|
||||
arch.substatus.loading_files=Загрузка файлов пакета
|
||||
arch.substatus.pre_hooks=Запуск хуков предварительных транзакций
|
||||
arch.substatus.retrieve_pkgs=Извлечение пакетов
|
||||
arch.sync.dep_breakage.reason={} требует {}
|
||||
arch.sync_databases.substatus=Синхронизация баз данных пакетов
|
||||
arch.sync_databases.substatus.error=Синхронизировать базу данных пакета не удалось
|
||||
arch.sync_databases.substatus.synchronized=Синхронизировано
|
||||
arch.task.aur.index.status=Создание локального индекса AUR
|
||||
arch.task.aur.index.substatus.checking=Проверка наличия обновлений
|
||||
arch.task.aur.index.substatus.download=Загрузка индекса AUR
|
||||
arch.task.aur.index.substatus.error.download=Ошибка соединения при загрузке индекса
|
||||
arch.task.aur.index.substatus.error.no_data=Ошибка: пустой индекс
|
||||
arch.task.aur.index.substatus.gen_index=Создание индекса
|
||||
arch.task.checking_settings=Проверка настроек
|
||||
arch.task.disabled=Отключено
|
||||
arch.task.disk_cache=Индексирование данных пакетов
|
||||
arch.task.disk_cache.checking=Проверка индекса
|
||||
arch.task.disk_cache.indexed=Проиндексировано
|
||||
arch.task.disk_cache.indexing=Индексирование
|
||||
arch.task.disk_cache.reading_files=Чтение файлов
|
||||
arch.task.disk_cache.waiting_aur_index=Ожидание {}
|
||||
arch.task.mirrors=Обновление зеркал
|
||||
arch.task.mirrors.cached=Обновление
|
||||
arch.task.optimizing=Оптимизация {}
|
||||
arch.task.sync_sb.status=Обновление {}
|
||||
arch.uninstall.clean_cached.error=Не удалось удалить старые версии {}, найденные на диске
|
||||
arch.uninstall.clean_cached.substatus=Удаление старых версий с диска
|
||||
arch.uninstall.error.hard_dep_in_hold=Невозможно удалить {}, поскольку одна из его зависимостей помечена как "InHold" (в удержании)
|
||||
arch.uninstall.required_by=Нижеперечисленные пакеты ({no}) для корректной работы зависят от {pkgs}
|
||||
arch.uninstall.required_by.warn=Чтобы продолжить, необходимо также удалить их
|
||||
arch.uninstall.unnecessary.all=Будут удалены следующие пакеты: {}
|
||||
arch.uninstall.unnecessary.cancel=Сохранить
|
||||
arch.uninstall.unnecessary.l1=Удаление пакетов прошло успешно!
|
||||
arch.uninstall.unnecessary.l2=Приведенные ниже пакеты, похоже, больше не нужны
|
||||
arch.uninstall.unnecessary.proceed=Удаление
|
||||
arch.uninstalling.conflict=Удаление конфликтующих пакетов
|
||||
arch.uninstalling.conflict.fail=Удаление этих конфликтующих пакетов оказалось невозможным: {}
|
||||
arch.update.disabled.tooltip=Этот пакет может быть обновлен только через действие "обновить систему"
|
||||
arch.update_summary.conflict_between=Конфликт между {} и {}
|
||||
arch.update_summary.to_install.dep_conflict=Конфликт между зависимостями {} и {}
|
||||
arch.update_summary.to_update.conflicts_dep=Конфликты с зависимостью {} от {}
|
||||
arch.update_summary.to_update.dep_conflicts=Зависимость {} конфликтует с {}
|
||||
arch.upgrade.caching_pkgs_data=Кэширование обновленных данных
|
||||
arch.upgrade.error.conflicting_files=Некоторые из обновляемых пакетов хотят перезаписать файлы других установленных пакетов
|
||||
arch.upgrade.error.dep_breakage=Обнаружены некоторые проблемы с нарушением зависимостей
|
||||
arch.upgrade.error.dep_breakage.item=Новая версия {} нарушает зависимость {}, требуемую установленной версией {}
|
||||
arch.upgrade.error.dep_breakage.proceed=Продолжать в любом случае
|
||||
arch.upgrade.error.dep_breakage.stop=Отменить обновление
|
||||
arch.upgrade.conflicting_files.proceed=Разрешить и продолжить
|
||||
arch.upgrade.conflicting_files.stop=Отмена обновления
|
||||
arch.upgrade.fail=Обновление пакета {} не удалось
|
||||
arch.upgrade.mthreaddownload.fail=Не удалось загрузить все пакеты для обновления
|
||||
arch.upgrade.success=Пакет {} успешно обновлен
|
||||
arch.upgrade.upgrade_aur_pkgs=Обновление пакетов AUR
|
||||
arch.upgrade.upgrade_repo_pkgs=Обновление пакетов из репозиториев
|
||||
arch.warning.disabled={} кажется, не установлен. Управлять пакетами Arch / AUR будет невозможно.
|
||||
arch.warning.aur_missing_dep={}, похоже, не установлен. Управление пакетами AUR станет невозможным.
|
||||
arch_repo.history.1_version=версия
|
||||
arch_repo.history.2_release=выпуск
|
||||
arch_repo.history.3_date=дата
|
||||
aur.history.1_version=Версия
|
||||
aur.history.2_release=Выпуск
|
||||
aur.history.3_date=Дата
|
||||
category.orphan=Пакет-сирота
|
||||
category.out_of_date=устаревший
|
||||
gem.arch.info=Пакеты программного обеспечения, доступные для дистрибутивов на базе Arch Linux
|
||||
gem.arch.label=Arch
|
||||
gem.arch.type.arch_repo.label=Arch - Репозиторий
|
||||
gem.arch.type.aur.label=Arch - AUR
|
||||
@@ -1,316 +0,0 @@
|
||||
arch.action.rebuild_check.allow=Allow reinstallation check
|
||||
arch.action.rebuild_check.allow.desc=Allows to verify the need of reinstalling the package
|
||||
arch.action.rebuild_check.allow.status=Allowing reinstallation check
|
||||
arch.action.rebuild_check.allow.confirm=Allow reinstallation check for {} ?
|
||||
arch.action.rebuild_check.ignore=Ignore reinstallation check
|
||||
arch.action.rebuild_check.ignore.desc=Do not verify if the package needs to be reinstalled on the system
|
||||
arch.action.rebuild_check.ignore.status=Ignoring reinstallation check
|
||||
arch.action.rebuild_check.ignore.confirm=Ignore reinstallation check for {} ?
|
||||
arch.action.db_locked.body.l1=Sistemin paket veritabanı kilitli.
|
||||
arch.action.db_locked.body.l2=Devam etmek için veritabanı kilidini açmak gerekiyor.
|
||||
arch.action.db_locked.confirmation=Veritabanı kilidini aç ve devam et
|
||||
arch.action.db_locked.error=Veritabanının kilidini açmak mümkün olmadı.
|
||||
arch.action.db_locked.title=Veritabanı kilitli
|
||||
arch.action.disable_pkgbuild_edition=Unmark PKGBUILD as editable
|
||||
arch.action.disable_pkgbuild_edition.confirm=Unmark PKGBUILD of {} as editable ?
|
||||
arch.action.disable_pkgbuild_edition.desc=Do not allow the package's PKGBUILD file to be edited before updating it
|
||||
arch.action.disable_pkgbuild_edition.status=Unmarking PKGBUILD as editable
|
||||
arch.action.enable_pkgbuild_edition=Mark PKGBUILD as editable
|
||||
arch.action.enable_pkgbuild_edition.confirm=Mark PKGBUILD of {} as editable ?
|
||||
arch.action.enable_pkgbuild_edition.desc=Allows the package's PKGBUILD file to be edited before updating it
|
||||
arch.action.enable_pkgbuild_edition.status=Marking PKGBUILD as editable
|
||||
arch.action.reinstall=Reinstall
|
||||
arch.action.reinstall.desc=Tries to install the package again
|
||||
arch.action.reinstall.status=Reinstalling
|
||||
arch.action.reinstall.confirm=Do you want to reinstall {} ?
|
||||
arch.action.reinstall.error.no_apidata=It was not possible to retrieve information of {} from AUR
|
||||
arch.aur.action.edit_pkgbuild.body=Edit the PKGBUILD file of {} before continuing ?
|
||||
arch.aur.install.pgp.body={} kurmak için aşağıdaki PGP anahtarlarını almak gereklidir
|
||||
arch.aur.install.pgp.receive_fail=PGP anahtarı alınamadı {}
|
||||
arch.aur.install.pgp.sign_fail=PGP anahtarı {} imzalanamadı
|
||||
arch.aur.install.pgp.substatus=PGP anahtarı alınıyor {}
|
||||
arch.aur.install.pgp.success=PGP anahtarları alındı ve imzalandı
|
||||
arch.aur.install.pgp.title=PGP anahtarları gerekli
|
||||
arch.aur.install.unknown_key.receive_error=Genel anahtar alınamadı {}
|
||||
arch.aur.install.unknown_key.status=Ortak anahtar alınıyor {}
|
||||
arch.aur.install.validity_check.body={} kurulumu için gereken kaynak dosyalardan bazıları sağlıklı değil.
|
||||
arch.aur.install.validity_check.proceed=Yine de devam etmek istiyor musunuz? ( önerilmez )
|
||||
arch.aur.install.validity_check.title=Bütünlük sorunları {}
|
||||
arch.aur.install.verifying_pgp=PGP anahtarları doğrulanıyor
|
||||
arch.aur.build.list_output=Checking built files
|
||||
arch.aur.sync.several_names.popup.body=The definition file (PKGBUILD) of {} configures the build of other packages
|
||||
arch.aur.sync.several_names.popup.bt_only_chosen=Build only {}
|
||||
arch.aur.sync.several_names.popup.bt_selected=Build selected too
|
||||
arch.building.package=Paket inşa ediliyor {}
|
||||
arch.can_work.not_arch_distro=Only available for ArchLinux based distributions
|
||||
arch.checking.conflicts={} ile çakışmalar kontrol ediliyor
|
||||
arch.checking.deps={} bağımlılıkları kontrol ediliyor
|
||||
arch.checking.missing_deps={} eksik bağımlılıkları kontrol ediliyor
|
||||
arch.clone=AUR deposu kopyalanıyor {}
|
||||
arch.category.remove_from_aur=Removed from AUR
|
||||
arch.config.aur=AUR paketleri
|
||||
arch.config.aur.tip=AUR paketlerinin yönetilmesine izin verir. git yüklenmeli.
|
||||
arch.config.aur_rebuild_detector=Check reinstallation need
|
||||
arch.config.aur_rebuild_detector.tip=It checks if packages built with old library versions require to be rebuilt. If a package needs to be rebuilt, it will be marked for update ({} must be installed)
|
||||
arch.config.aur_rebuild_detector_no_bin=Ignore binaries ({})
|
||||
arch.config.aur_rebuild_detector_no_bin.tip=If binary packages named as "package-bin" should be ignored by {} ({})
|
||||
arch.config.automatch_providers=Auto-match dependency by name
|
||||
arch.config.automatch_providers.tip=It associates automatically a package to a dependency if both names match. Otherwise all providers for a given dependency will be displayed.
|
||||
arch.config.aur_build_dir=Build directory
|
||||
arch.config.aur_build_dir.tip=It define a custom directory where the AUR packages will be built. Default: {}.
|
||||
arch.config.aur_build_only_chosen=Build only chosen
|
||||
arch.config.aur_build_only_chosen.tip=Some AUR packages have a common PKGBUILD shared with other packages and that defines build instructions for each one. This property enabled will ensure that only the chosen package will be built.
|
||||
arch.config.aur_remove_build_dir=Remove build directory
|
||||
arch.config.aur_remove_build_dir.tip=If a package's generated build directory should be removed after the operations is finished.
|
||||
arch.config.categories_exp=Categories expiration
|
||||
arch.config.categories_exp.tip=It defines the expiration time (in HOURS) of the packages categories mapping file stored in disc. Use 0 so that it is always updated during initialization.
|
||||
arch.config.clean_cache=Önbelleği temizle
|
||||
arch.config.clean_cache.tip=Disk üzerinde kurulu bir paketin eski sürümlerinin kaldırma sırasında kaldırılıp kaldırılmayacağı
|
||||
arch.config.check_dependency_breakage=Check dependency version breakage
|
||||
arch.config.check_dependency_breakage.tip=If, during the verification of upgrade requirements, specific versions of dependencies must also be checked. Example: package A depends on version 1.0 of B.
|
||||
arch.config.edit_aur_pkgbuild=Edit PKGBUILD
|
||||
arch.config.edit_aur_pkgbuild.tip=If the PKGBUILD file of an AUR package should be displayed for editing before its installation/upgrade/downgrade
|
||||
arch.config.aur_idx_exp=Index expiration
|
||||
arch.config.aur_idx_exp.tip=It defines the period (in HOURS) for the AUR index stored in disc to be considered up to date during the initialization process. Use 0 so that it is always updated.
|
||||
arch.config.mirrors_sort_limit=Yansı sıralama sınırı
|
||||
arch.config.mirrors_sort_limit.tip=Hız sıralama için kullanılacak maksimum yansı sayısını tanımlar. Sınırsız olması için 0 kullanın veya sıralamayı devre dışı bırakmak için boş bırakın.
|
||||
arch.config.optimize=Optimize
|
||||
arch.config.optimize.tip=Paketlerin kurulumunu, yükseltilmesini ve indirilmesini hızlandırmak için optimize edilmiş ayarlar kullanılacak, aksi takdirde sistem ayarları kullanılacak
|
||||
arch.config.pacman_mthread_download=Multithreaded download (repositories)
|
||||
arch.config.pacman_mthread_download.tip=Whether the repository packages should be downloaded with a tool that works with threads (it may be faster). pacman-mirrors must be installed.
|
||||
arch.config.prefer_repository_provider=Prefer repository dependencies
|
||||
arch.config.prefer_repository_provider.tip=Automatically picks the single package from the repositories among several external ({}) available as the provider for a given dependency
|
||||
arch.config.refresh_mirrors=Başlangıçta yansıları yenile
|
||||
arch.config.refresh_mirrors.tip=Paket yansılarını başlangıçta günde bir kez yenileyin
|
||||
arch.config.repos=Depo paketleri
|
||||
arch.config.repos.tip=Paketleri depolardan yönetmeye izin verir
|
||||
arch.config.suggest_optdep_uninstall=Uninstall optional dependencies
|
||||
arch.config.suggest_optdep_uninstall.tip=If the optional dependencies associated with uninstalled packages should be suggested for uninstallation. Only the optional dependencies that are not dependencies of other packages will be suggested.
|
||||
arch.config.suggest_unneeded_uninstall=Uninstall unneeded dependencies
|
||||
arch.config.suggest_unneeded_uninstall.tip=If the dependencies apparently no longer necessary associated with the uninstalled packages should be suggested for uninstallation. When this property is enabled it automatically disables the property {}.
|
||||
arch.config.suggestions_exp=Suggestions expiration
|
||||
arch.config.suggestions_exp.tip=It defines the period (in hours) in which the suggestions stored in disc will be considered up to date. Use 0 if you always want to update them.
|
||||
arch.config.sync_dbs=Paket veritabanlarını senkronize et
|
||||
arch.config.sync_dbs.tip=İlk veritabanını kurmadan, yükseltmeden veya indirmeden önce paket veritabanlarını günde bir kez senkronize eder. Bu seçenek, bu işlemler sırasında hataların önlenmesine yardımcı olur.
|
||||
arch.config.sync_dbs_start.tip=Başlatma sırasında paket veritabanlarını günde bir kez senkronize eder
|
||||
arch.custom_action.clean_cache=Önbelleği temizle
|
||||
arch.custom_action.clean_cache.desc=Removes all the downloade package files from the disk cache
|
||||
arch.custom_action.clean_cache.fail=Önbellek temizlenirken bir hata oluştu
|
||||
arch.custom_action.clean_cache.msg1=Önbellek, eski paket sürümlerinin dosyalarının depolandığı bir sistem dizinidir
|
||||
arch.custom_action.clean_cache.msg2=Temizlenmesi sisteminize zarar vermeden paket depolama alanını boşaltır
|
||||
arch.custom_action.clean_cache.msg3=Bir eylemi engelleyen bütünlük sorunları olan indirilen paketler olduğunda da yardımcı olur
|
||||
arch.custom_action.clean_cache.no_dir=} önbellek dizini mevcut değil
|
||||
arch.custom_action.clean_cache.status=Önbellek temizleniyor
|
||||
arch.custom_action.clean_cache.success=Önbellek temizleme tamamlandı !
|
||||
arch.custom_action.refresh_dbs=Paket veritabanlarını eşitle
|
||||
arch.custom_action.refresh_dbs.desc=Synchronizes the available packages on the repositories
|
||||
arch.custom_action.refresh_dbs.failed=Paket veritabanları eşitlenemedi
|
||||
arch.custom_action.refresh_mirrors=Yansıları yenile
|
||||
arch.custom_action.refresh_mirrors.desc=Allows to choose the repository mirrors and sort them by the fastest
|
||||
arch.custom_action.refresh_mirrors.failed=Yansılar yenilenemedi
|
||||
arch.custom_action.refresh_mirrors.location.all=Tümü
|
||||
arch.custom_action.refresh_mirrors.location.all.tip=Bu seçenek işaretlenirse, diğerleri yoksayılır.
|
||||
arch.custom_action.refresh_mirrors.select_label=İstediğiniz konumları kontrol edin
|
||||
arch.custom_action.refresh_mirrors.status.sorting=Yansıları hıza göre sırala
|
||||
arch.custom_action.refresh_mirrors.status.updating=Yansılar güncelleniyor
|
||||
arch.custom_action.setup_snapd=Check Snaps support
|
||||
arch.custom_action.setup_snapd.desc=Checks if the Snaps support are properly enabled on the system
|
||||
snap.custom_action.setup_snapd.missing_link=Create the link {} for {}
|
||||
arch.custom_action.setup_snapd.status=Checking Snaps support
|
||||
snap.custom_action.setup_snapd.ready=Ready!
|
||||
snap.custom_action.setup_snapd.ready.body=The system is ready to work with Snaps!
|
||||
snap.custom_action.setup_snapd.required_actions=Actions required for Snaps to work correctly
|
||||
snap.custom_action.setup_snapd.service_disabled=Enable the service {}
|
||||
snap.custom_action.setup_snapd.service_inactive=Start the service {}
|
||||
arch.custom_action.upgrade_system=Sistemi hızlı yükselt
|
||||
arch.custom_action.upgrade_system.desc=Tries to upgrade the system with a single pacman call
|
||||
arch.custom_action.upgrade_system.no_updates=Güncelleme yok
|
||||
arch.custom_action.upgrade_system.pkgs=Aşağıdaki paketler yükseltilecek
|
||||
arch.custom_action.upgrade_system.status=Sistem yükseltiliyor
|
||||
arch.custom_action.upgrade_system.substatus=Paketler yükseltiliyor
|
||||
arch.custom_action.upgrade_system.success.line1=Sistem yükseltme tamamlandı!
|
||||
arch.custom_action.upgrade_system.success.line2=Bazı değişiklikler için sistemin yeniden başlatılması gerekebilir.
|
||||
arch.custom_action.upgrade_system.success.line3=Şimdi yeniden başlat ?
|
||||
arch.dialog.providers.line1=Bazı bağımlılıklar için birden çok sağlayıcı var
|
||||
arch.dialog.providers.line2=İstediklerinizi seçin
|
||||
arch.downgrade.error=Hata
|
||||
arch.downgrade.impossible=Sürüm düşürmek mümkün değil {}
|
||||
arch.downgrade.install_older=Sürüm düşürme
|
||||
arch.downgrade.reading_commits=Depo çalışmalarını oku
|
||||
arch.downgrade.repo_pkg.no_versions=Diskte eski sürüm bulunamadı
|
||||
arch.downgrade.searching_stored=Diskteki eski sürümlere bakılıyor
|
||||
arch.downgrade.version_found=Geçerli paket sürümü bulundu
|
||||
arch.aur.error.missing_root_dep={dep} is not installed and is required for installing {aur} packages as the {root} user
|
||||
arch.aur.error.add_builder_user=It was not possible to create the user {user} for building {aur} packages
|
||||
arch.info.00_pkg_build=pkgbuild
|
||||
arch.info.00_url=URL
|
||||
arch.info.01_id=kimlik
|
||||
arch.info.02_name=isim
|
||||
arch.info.03_description=açıklama
|
||||
arch.info.03_version=sürüm
|
||||
arch.info.04_exec=Executable
|
||||
arch.info.04_orphan=orphan
|
||||
arch.info.04_orphan.true=yes
|
||||
arch.info.04_orphan.false=no
|
||||
arch.info.04_out_of_date=out of date
|
||||
arch.info.04_out_of_date.true=yes
|
||||
arch.info.04_out_of_date.false=no
|
||||
arch.info.04_popularity=rağbet
|
||||
arch.info.05_votes=oylar
|
||||
arch.info.06_package_base=taban paket
|
||||
arch.info.07_maintainer=bakıcı
|
||||
arch.info.08_first_submitted=ilk gönderen
|
||||
arch.info.09_last_modified=son değişiklik
|
||||
arch.info.10_url=url indir
|
||||
arch.info.11_pkg_build_url=url pkgbuild
|
||||
arch.info.12_makedepends=derleme bağımlılıkları
|
||||
arch.info.13_dependson=kurulum bağımlılıkları
|
||||
arch.info.13_pkg_build=pkgbuild
|
||||
arch.info.14_installed_files=Yüklü dosyalar
|
||||
arch.info.14_optdepends=tercihe bağlı bağımlılıklar
|
||||
arch.info.15_checkdepends=bağımlılıklar kontrol ediliyor
|
||||
arch.info.arch=arch
|
||||
arch.info.arch.any=herhangi
|
||||
arch.info.architecture=mimari
|
||||
arch.info.architecture.any=herhangi
|
||||
arch.info.build date=inşa tarihi
|
||||
arch.info.conflicts with=çakışmalar
|
||||
arch.info.depends=bağımlılıklar
|
||||
arch.info.depends on=bağımlılığı
|
||||
arch.info.description=açıklama
|
||||
arch.info.download size=İndirme boyutu
|
||||
arch.info.install date=kurulum tarihi
|
||||
arch.info.install reason=yükleme nedeni
|
||||
arch.info.install reason.explicitly installed=doğrudan kurulmuş
|
||||
arch.info.install reason.installed as a dependency for another package=başka bir paketin bağımlılığı
|
||||
arch.info.install script=kurulum betiği
|
||||
arch.info.install script.no=hayır
|
||||
arch.info.installed files=yüklü dosyalar
|
||||
arch.info.installed size=kurulum boyutu
|
||||
arch.info.last_modified=son değişiklik
|
||||
arch.info.license=lisans
|
||||
arch.info.licenses=lisanslar
|
||||
arch.info.licenses.custom=özel
|
||||
arch.info.name=isim
|
||||
arch.info.optdepends=tercihli bağımlılıklar
|
||||
arch.info.optional deps=tercihli bağımlılıklar
|
||||
arch.info.optional for=isteğe bağlı
|
||||
arch.info.options=seçenekler
|
||||
arch.info.packager=paketçi
|
||||
arch.info.packager.unknown packager=bilinmeyen
|
||||
arch.info.pkgdesc=açıklama
|
||||
arch.info.pkgname=isim
|
||||
arch.info.pkgrel=sürüm
|
||||
arch.info.pkgver=sürüm inşa
|
||||
arch.info.provides=sağlayıcı
|
||||
arch.info.replaces=yerini alan
|
||||
arch.info.required by=gerekli
|
||||
arch.info.source=kaynak
|
||||
arch.info.url=bağlantı
|
||||
arch.info.validated by=doğrulayıcı
|
||||
arch.info.validated by.signature=imza
|
||||
arch.info.validpgpkeys=PGP doğrulama anahtarı
|
||||
arch.info.version=sürüm
|
||||
arch.install.aur.root_error.body=Kök kullanıcı olarak bir paketin yüklenmesine, yükseltilmesine veya sürümünün düşürülmesine izin verilmez
|
||||
arch.install.aur.root_error.title=Eyleme izin verilmiyor
|
||||
arch.install.aur.unknown_key.body=Yüklemeye devam etmek için {} aşağıdaki ortak anahtara güvenmek gerekiyor {}
|
||||
arch.install.aur.unknown_key.title=Ortak anahtar gerekli
|
||||
arch.install.conflict.popup.body={} Uygulamaları çakışıyor. Diğerini kurmak için birini kaldırmalısınız. Devam et ?
|
||||
arch.install.conflict.popup.title=Çakışma tespit edildi
|
||||
arch.install.dep_not_found.body.l1=Gerekli bağımlılık {dep}{source} ne AUR ne de resmi depolarda bulunamadı.
|
||||
arch.install.dep_not_found.body.l2=Bir paket veritabanı senkronizasyon sorunu olabilir.
|
||||
arch.install.dep_not_found.body.l3=Operation cancelled.
|
||||
arch.install.dep_not_found.title=Bağımlılık bulunamadı
|
||||
arch.install.dependency.install=Paket bağımlılığını yükleniyor {}
|
||||
arch.install.dependency.install.error=Bağımlı paketler yüklenemedi: {}. {} Kurulumu iptal edildi.
|
||||
arch.install.error.conflicting_files=The package {} wants to overwrite files from other installed packages
|
||||
arch.install.error.conflicting_files.proceed=Allow
|
||||
arch.install.error.conflicting_files.stop=Cancel installation
|
||||
arch.install.optdep.error=Tercihe bağlı paketler yüklenemedi: {}
|
||||
arch.install.optdeps.request.body=Check the optional associated packages below that you want to install
|
||||
arch.install.optdeps.request.success={pkg} was successfully installed !
|
||||
arch.install.optdeps.request.title=İsteğe bağlı bağımlılıklar
|
||||
arch.installing.package={} Paketi yükleniyor
|
||||
arch.checking_unnecessary_deps=Artık gerekli olmayan paketler olup olmadığını kontrol et
|
||||
arch.makepkg.optimizing=Derlemeyi optimize et
|
||||
arch.missing_deps.body=The following dependencies ({deps}) will be installed
|
||||
arch.missing_deps.title=Eksik bağımlılıklar
|
||||
arch.missing_deps_found={} için eksik bağımlılıklar
|
||||
arch.mthread_downloaded.error.cache_dir=It was not possible to create the cache directory {}
|
||||
arch.mthread_downloaded.error.cancelled=Operation cancelled
|
||||
arch.optdeps.checking={} İsteğe bağlı bağımlılıkları kontrol et
|
||||
arch.package.requires_rebuild=It needs to be reinstalled
|
||||
arch.providers=sağlayıcılar
|
||||
arch.substatus.conflicts=Checking for conflicts
|
||||
arch.substatus.disk_space=Checking available disk space
|
||||
arch.substatus.integrity=Checking packages integrity
|
||||
arch.substatus.keyring=Checking keyring
|
||||
arch.substatus.loading_files=Loading package files
|
||||
arch.substatus.pre_hooks=Running pre-transaction hooks
|
||||
arch.substatus.retrieve_pkgs=Retrieving packages
|
||||
arch.sync.dep_breakage.reason={} requires {}
|
||||
arch.sync_databases.substatus=Paket veritabanı eşitleniyor
|
||||
arch.sync_databases.substatus.error=Paket veritabanı eşitlenemedi
|
||||
arch.sync_databases.substatus.synchronized=Synchronized
|
||||
arch.task.aur.index.status=Generating local AUR index
|
||||
arch.task.aur.index.substatus.checking=Checking for updates
|
||||
arch.task.aur.index.substatus.download=Downloading the AUR index
|
||||
arch.task.aur.index.substatus.error.download=Connection error while downloading the index
|
||||
arch.task.aur.index.substatus.error.no_data=Error: empty index
|
||||
arch.task.aur.index.substatus.gen_index=Generating index
|
||||
arch.task.checking_settings=Checking settings
|
||||
arch.task.disabled=Disabled
|
||||
arch.task.disk_cache=Indexing packages data
|
||||
arch.task.disk_cache.checking=Checking index
|
||||
arch.task.disk_cache.indexed=Indexed
|
||||
arch.task.disk_cache.indexing=Indexing
|
||||
arch.task.disk_cache.reading_files=Reading files
|
||||
arch.task.disk_cache.waiting_aur_index=Waiting {}
|
||||
arch.task.mirrors=Yansılar yenileniyor
|
||||
arch.task.mirrors.cached=Refreshed
|
||||
arch.task.optimizing=Uygun hale getiriliyor {}
|
||||
arch.task.sync_sb.status={} güncelleniyor
|
||||
arch.uninstall.clean_cached.error=Diskte bulunan eski {} sürümleri kaldırılamadı
|
||||
arch.uninstall.clean_cached.substatus=Eski sürümler diskten kaldırılıyor
|
||||
arch.uninstall.error.hard_dep_in_hold=It is not possible to uninstall {} because one of its dependencies is marked as "InHold"
|
||||
arch.uninstall.required_by=The packages ({no}) below depend on {pkgs} to work properly
|
||||
arch.uninstall.required_by.warn=Devam etmek için bunları da kaldırmak gerekir
|
||||
arch.uninstall.unnecessary.all=Aşağıdaki {} paketler kaldırılacak
|
||||
arch.uninstall.unnecessary.cancel=Tut
|
||||
arch.uninstall.unnecessary.l1=Packages successfully uninstalled!
|
||||
arch.uninstall.unnecessary.l2=The packages below seem to be no longer necessary
|
||||
arch.uninstall.unnecessary.proceed=Kaldır
|
||||
arch.uninstalling.conflict=Uninstalling conflicting packages
|
||||
arch.uninstalling.conflict.fail=It was not possible to uninstall the conflicting packages: {}
|
||||
arch.update.disabled.tooltip=Bu paket yalnızca "Hızlı sistem yükseltme" işlemi ile yükseltilebilir
|
||||
arch.update_summary.conflict_between={} Ve {} arasında çakışma
|
||||
arch.update_summary.to_install.dep_conflict={} ve {} bağımlılıkları arasındaki çakışma
|
||||
arch.update_summary.to_update.conflicts_dep={} / {} bağımlılığıyla ilgili çakışmalar
|
||||
arch.update_summary.to_update.dep_conflicts=Bağımlılık {} ile {} çakışıyor
|
||||
arch.upgrade.caching_pkgs_data=Yükseltme verileri önbelleğe alınıyor
|
||||
arch.upgrade.error.conflicting_files=Some of the packages being upgraded want to overwrite files of another installed packages
|
||||
arch.upgrade.error.dep_breakage=Some dependency breakage issues have been detected
|
||||
arch.upgrade.error.dep_breakage.item=The new version of {} breaks the dependency {} required by the installed version of {}
|
||||
arch.upgrade.error.dep_breakage.proceed=Proceed anyway
|
||||
arch.upgrade.error.dep_breakage.stop=Cancel upgrade
|
||||
arch.upgrade.conflicting_files.proceed=Allow and continue
|
||||
arch.upgrade.conflicting_files.stop=Cancel upgrading
|
||||
arch.upgrade.fail={} paketi yükseltilemedi
|
||||
arch.upgrade.mthreaddownload.fail=It was not possible to download all packages for upgrading
|
||||
arch.upgrade.success={} paketi başarıyla yükseltildi
|
||||
arch.upgrade.upgrade_aur_pkgs=AUR paketleri yükseltiliyor
|
||||
arch.upgrade.upgrade_repo_pkgs=Resmi depo paketleri yükseltiliyor
|
||||
arch.warning.disabled={} kurulu değil gibi görünüyor. Arch / AUR paketlerini yönetmek mümkün olmayacaktır.
|
||||
arch.warning.aur_missing_dep={} seems not to be installed. It will not be possible to manage AUR packages.
|
||||
arch_repo.history.1_version=sürüm
|
||||
arch_repo.history.2_release=sürüm inşa
|
||||
arch_repo.history.3_date=tarih
|
||||
aur.history.1_version=sürüm
|
||||
aur.history.2_release=sürüm inşa
|
||||
aur.history.3_date=tarih
|
||||
category.orphan=orphan
|
||||
category.out_of_date=out of date
|
||||
gem.arch.info=Arch Linux tabanlı dağıtımlar için mevcut yazılım paketleri
|
||||
gem.arch.label=Arch
|
||||
gem.arch.type.arch_repo.label=Arch - Depoları
|
||||
gem.arch.type.aur.label=Arch - AUR
|
||||
@@ -1,316 +0,0 @@
|
||||
arch.action.rebuild_check.allow=允许重新安装检查
|
||||
arch.action.rebuild_check.allow.desc=允许验证是否需要重新安装包
|
||||
arch.action.rebuild_check.allow.status=允许重新安装检查
|
||||
arch.action.rebuild_check.allow.confirm=允许重新安装检查 {} 吗？
|
||||
arch.action.rebuild_check.ignore=忽略重新安装检查
|
||||
arch.action.rebuild_check.ignore.desc=不验证包是否需要在系统上重新安装
|
||||
arch.action.rebuild_check.ignore.status=忽略重新安装检查
|
||||
arch.action.rebuild_check.ignore.confirm=忽略重新安装检查 {} 吗？
|
||||
arch.action.db_locked.body.l1=系统的包数据库已锁定。
|
||||
arch.action.db_locked.body.l2=需要解锁才能继续。
|
||||
arch.action.db_locked.confirmation=解锁并继续
|
||||
arch.action.db_locked.error=无法解锁数据库。
|
||||
arch.action.db_locked.title=数据库已锁定
|
||||
arch.action.disable_pkgbuild_edition=取消标记 PKGBUILD 为可编辑
|
||||
arch.action.disable_pkgbuild_edition.confirm=取消标记 {} 的 PKGBUILD 为可编辑吗？
|
||||
arch.action.disable_pkgbuild_edition.desc=在更新之前不允许编辑包的 PKGBUILD 文件
|
||||
arch.action.disable_pkgbuild_edition.status=取消标记 PKGBUILD 为可编辑
|
||||
arch.action.enable_pkgbuild_edition=标记 PKGBUILD 为可编辑
|
||||
arch.action.enable_pkgbuild_edition.confirm=标记 {} 的 PKGBUILD 为可编辑吗？
|
||||
arch.action.enable_pkgbuild_edition.desc=允许在更新之前编辑包的 PKGBUILD 文件
|
||||
arch.action.enable_pkgbuild_edition.status=标记 PKGBUILD 为可编辑
|
||||
arch.action.reinstall=重新安装
|
||||
arch.action.reinstall.desc=尝试重新安装包
|
||||
arch.action.reinstall.status=正在重新安装
|
||||
arch.action.reinstall.confirm=是否要重新安装 {} ？
|
||||
arch.action.reinstall.error.no_apidata=无法从 AUR 获取 {} 的信息
|
||||
arch.aur.action.edit_pkgbuild.body=在继续之前编辑 {} 的 PKGBUILD 文件吗？
|
||||
arch.aur.install.pgp.body=要安装 {}，需要接收以下 PGP 密钥
|
||||
arch.aur.install.pgp.receive_fail=无法接收 PGP 密钥 {}
|
||||
arch.aur.install.pgp.sign_fail=无法签署 PGP 密钥 {}
|
||||
arch.aur.install.pgp.substatus=接收 PGP 密钥 {}
|
||||
arch.aur.install.pgp.success=已接收并签署 PGP 密钥
|
||||
arch.aur.install.pgp.title=需要 PGP 密钥
|
||||
arch.aur.install.unknown_key.receive_error=无法接收公钥 {}
|
||||
arch.aur.install.unknown_key.status=接收公钥 {}
|
||||
arch.aur.install.validity_check.body={} 安装所需的一些源文件不健康。
|
||||
arch.aur.install.validity_check.proceed=是否仍要继续？(不建议)
|
||||
arch.aur.install.validity_check.title=完整性问题 {}
|
||||
arch.aur.install.verifying_pgp=正在验证 PGP 密钥
|
||||
arch.aur.build.list_output=检查构建的文件
|
||||
arch.aur.sync.several_names.popup.body={} 的定义文件(PKGBUILD)配置了其他软件包的构建
|
||||
arch.aur.sync.several_names.popup.bt_only_chosen=仅构建 {}
|
||||
arch.aur.sync.several_names.popup.bt_selected=同时构建选定项
|
||||
arch.building.package=构建软件包 {}
|
||||
arch.can_work.not_arch_distro=仅适用于基于 ArchLinux 的发行版
|
||||
arch.checking.conflicts=检查与 {} 的任何冲突
|
||||
arch.checking.deps=检查 {} 的依赖项
|
||||
arch.checking.missing_deps=验证 {} 缺失的依赖项
|
||||
arch.clone=克隆 AUR 仓库 {}
|
||||
arch.category.remove_from_aur=从 AUR 中删除
|
||||
arch.config.aur=AUR 软件包
|
||||
arch.config.aur.tip=允许管理 AUR 软件包。必须安装 git。
|
||||
arch.config.aur_rebuild_detector=检查重新安装需求
|
||||
arch.config.aur_rebuild_detector.tip=检查使用旧库版本构建的软件包是否需要重新安装。如果需要重新安装软件包，将标记为更新(必须安装 {})。
|
||||
arch.config.aur_rebuild_detector_no_bin=忽略二进制文件 ({})
|
||||
arch.config.aur_rebuild_detector_no_bin.tip=是否应忽略由 {} 命名的二进制软件包("package-bin")。
|
||||
arch.config.automatch_providers=按名称自动匹配依赖项
|
||||
arch.config.automatch_providers.tip=如果名称匹配，自动将软件包与依赖项关联。否则，将显示给定依赖项的所有提供者。
|
||||
arch.config.aur_build_dir=构建目录
|
||||
arch.config.aur_build_dir.tip=定义 AUR 软件包将构建的自定义目录。默认: {}。
|
||||
arch.config.aur_build_only_chosen=仅构建已选择项
|
||||
arch.config.aur_build_only_chosen.tip=一些 AUR 软件包与其他软件包共享相同的 PKGBUILD 文件，该文件为每个软件包定义了构建说明。启用此属性将确保仅构建已选择的软件包。
|
||||
arch.config.aur_remove_build_dir=删除构建目录
|
||||
arch.config.aur_remove_build_dir.tip=操作完成后是否应删除软件包生成的构建目录。
|
||||
arch.config.categories_exp=类别过期
|
||||
arch.config.categories_exp.tip=定义存储在磁盘上的软件包类别映射文件的过期时间(以小时为单位)。使用 0 以便在初始化期间始终更新。
|
||||
arch.config.clean_cache=删除旧版本
|
||||
arch.config.clean_cache.tip=在卸载期间是否应删除磁盘缓存中的软件包的旧版本
|
||||
arch.config.check_dependency_breakage=检查依赖版本破坏
|
||||
arch.config.check_dependency_breakage.tip=在验证升级要求期间是否还必须检查依赖项的特定版本。例如：软件包 A 依赖于 B 的版本 1.0。
|
||||
arch.config.edit_aur_pkgbuild=编辑 PKGBUILD
|
||||
arch.config.edit_aur_pkgbuild.tip=是否应在安装/升级/降级 AUR 软件包之前显示其 PKGBUILD 文件以进行编辑
|
||||
arch.config.aur_idx_exp=索引过期
|
||||
arch.config.aur_idx_exp.tip=定义存储在磁盘上的 AUR 索引在初始化过程中被视为最新的期限(以小时为单位)。使用 0 以便在初始化期间始终更新。
|
||||
arch.config.mirrors_sort_limit=镜像排序限制
|
||||
arch.config.mirrors_sort_limit.tip=定义将用于速度排序的最大镜像数。使用 0 不设限制，或者留空以禁用排序。
|
||||
arch.config.optimize=优化
|
||||
arch.config.optimize.tip=将使用优化的设置，以使软件包的安装、升级和降级更快，否则将使用系统设置。
|
||||
arch.config.pacman_mthread_download=多线程下载(仓库)
|
||||
arch.config.pacman_mthread_download.tip=是否应使用支持线程的工具(可能更快)下载仓库软件包。必须安装 pacman-mirrors。
|
||||
arch.config.prefer_repository_provider=优先使用仓库依赖项
|
||||
arch.config.prefer_repository_provider.tip=在多个外部提供程序中，是否自动选择与给定依赖项相关的仓库软件包。
|
||||
arch.config.refresh_mirrors=启动时刷新镜像
|
||||
arch.config.refresh_mirrors.tip=在启动时每天刷新一次软件包镜像
|
||||
arch.config.repos=仓库软件包
|
||||
arch.config.repos.tip=允许管理来自仓库集的软件包
|
||||
arch.config.suggest_optdep_uninstall=卸载可选依赖项
|
||||
arch.config.suggest_optdep_uninstall.tip=是否应建议卸载已卸载软件包的关联可选依赖项。将仅建议不是其他软件包的依赖项的可选依赖项。
|
||||
arch.config.suggest_unneeded_uninstall=卸载不需要的依赖项
|
||||
arch.config.suggest_unneeded_uninstall.tip=是否应建议卸载与已卸载软件包显然不再需要的依赖项。启用此属性会自动禁用属性 {}。
|
||||
arch.config.suggestions_exp=建议过期
|
||||
arch.config.suggestions_exp.tip=定义存储在磁盘中的建议被视为最新的期限(以小时为单位)。使用 0 如果您始终希望更新它们。
|
||||
arch.config.sync_dbs=同步软件包数据库
|
||||
arch.config.sync_dbs.tip=在第一次安装、升级或降级软件包之前，每天同步一次软件包数据库。此选项有助于防止这些操作期间的错误。
|
||||
arch.config.sync_dbs_start.tip=在初始化期间每天同步一次软件包数据库
|
||||
arch.custom_action.clean_cache=清理缓存
|
||||
arch.custom_action.clean_cache.desc=从磁盘缓存中删除所有下载的软件包文件
|
||||
arch.custom_action.clean_cache.fail=清理缓存时发生错误
|
||||
arch.custom_action.clean_cache.msg1=缓存是存储旧软件包版本文件的系统目录
|
||||
arch.custom_action.clean_cache.msg2=清理它会释放存储空间，而不会损害您的系统
|
||||
arch.custom_action.clean_cache.msg3=还有下载的软件包存在完整性问题，阻止了某些操作
|
||||
arch.custom_action.clean_cache.no_dir=缓存目录 {} 不存在
|
||||
arch.custom_action.clean_cache.status=清理缓存
|
||||
arch.custom_action.clean_cache.success=缓存成功清理！
|
||||
arch.custom_action.refresh_dbs=同步软件包数据库
|
||||
arch.custom_action.refresh_dbs.desc=同步可用仓库上的软件包
|
||||
arch.custom_action.refresh_dbs.failed=无法同步软件包数据库
|
||||
arch.custom_action.refresh_mirrors=刷新镜像
|
||||
arch.custom_action.refresh_mirrors.desc=允许选择仓库镜像并按最快的顺序排列它们
|
||||
arch.custom_action.refresh_mirrors.failed=无法刷新镜像
|
||||
arch.custom_action.refresh_mirrors.location.all=全部
|
||||
arch.custom_action.refresh_mirrors.location.all.tip=如果选中此选项，其他选项将被忽略。
|
||||
arch.custom_action.refresh_mirrors.select_label=选择所需的位置
|
||||
arch.custom_action.refresh_mirrors.status.sorting=按速度排序镜像
|
||||
arch.custom_action.refresh_mirrors.status.updating=正在更新镜像
|
||||
arch.custom_action.setup_snapd=检查 Snap 支持
|
||||
arch.custom_action.setup_snapd.desc=检查系统上是否正确启用了 Snap 支持
|
||||
snap.custom_action.setup_snapd.missing_link=为 {} 创建链接 {}
|
||||
arch.custom_action.setup_snapd.status=检查 Snap 支持
|
||||
snap.custom_action.setup_snapd.ready=准备就绪！
|
||||
snap.custom_action.setup_snapd.ready.body=系统已准备好使用 Snaps！
|
||||
snap.custom_action.setup_snapd.required_actions=使 Snaps 正常工作所需的操作
|
||||
snap.custom_action.setup_snapd.service_disabled=启用服务 {}
|
||||
snap.custom_action.setup_snapd.service_inactive=启动服务 {}
|
||||
arch.custom_action.upgrade_system=快速系统升级
|
||||
arch.custom_action.upgrade_system.desc=尝试使用单个 pacman 调用升级系统
|
||||
arch.custom_action.upgrade_system.no_updates=没有可用的更新
|
||||
arch.custom_action.upgrade_system.pkgs=以下软件包将被升级
|
||||
arch.custom_action.upgrade_system.status=升级系统
|
||||
arch.custom_action.upgrade_system.substatus=升级软件包
|
||||
arch.custom_action.upgrade_system.success.line1=系统成功升级！
|
||||
arch.custom_action.upgrade_system.success.line2=某些更改可能需要重新启动系统才能生效。
|
||||
arch.custom_action.upgrade_system.success.line3=现在重新启动吗？
|
||||
arch.dialog.providers.line1=某些依赖项有多个提供者
|
||||
arch.dialog.providers.line2=选择您想要的提供者
|
||||
arch.downgrade.error=错误
|
||||
arch.downgrade.impossible=无法降级 {}
|
||||
arch.downgrade.install_older=安装较旧版本
|
||||
arch.downgrade.reading_commits=读取仓库提交
|
||||
arch.downgrade.repo_pkg.no_versions=磁盘上找不到旧版本
|
||||
arch.downgrade.searching_stored=在磁盘上查找旧版本
|
||||
arch.downgrade.version_found=找到当前软件包版本
|
||||
arch.aur.error.missing_root_dep={dep} 未安装，但在以 {root} 用户身份安装 {aur} 软件包时需要
|
||||
arch.aur.error.add_builder_user=无法创建构建 {aur} 软件包的用户 {user}
|
||||
arch.info.00_pkg_build=pkgbuild
|
||||
arch.info.00_url=URL
|
||||
arch.info.01_id=id
|
||||
arch.info.02_name=name
|
||||
arch.info.03_description=描述
|
||||
arch.info.03_version=版本
|
||||
arch.info.04_exec=可执行文件
|
||||
arch.info.04_orphan=孤儿
|
||||
arch.info.04_orphan.true=yes
|
||||
arch.info.04_orphan.false=no
|
||||
arch.info.04_out_of_date=过时
|
||||
arch.info.04_out_of_date.true=yes
|
||||
arch.info.04_out_of_date.false=no
|
||||
arch.info.04_popularity=流行度
|
||||
arch.info.05_votes=投票
|
||||
arch.info.06_package_base=软件包基础
|
||||
arch.info.07_maintainer=维护者
|
||||
arch.info.08_first_submitted=首次提交
|
||||
arch.info.09_last_modified=上次修改
|
||||
arch.info.10_url=下载链接
|
||||
arch.info.11_pkg_build_url=pkgbuild 链接
|
||||
arch.info.12_makedepends=编译依赖项
|
||||
arch.info.13_dependson=安装依赖项
|
||||
arch.info.13_pkg_build=pkgbuild
|
||||
arch.info.14_installed_files=已安装文件
|
||||
arch.info.14_optdepends=可选依赖项
|
||||
arch.info.15_checkdepends=检查依赖项
|
||||
arch.info.arch=架构
|
||||
arch.info.arch.any=任意
|
||||
arch.info.architecture=体系结构
|
||||
arch.info.architecture.any=任意
|
||||
arch.info.build date=构建日期
|
||||
arch.info.conflicts with=与之冲突
|
||||
arch.info.depends=依赖
|
||||
arch.info.depends on=取决于
|
||||
arch.info.description=描述
|
||||
arch.info.download size=下载大小
|
||||
arch.info.install date=安装日期
|
||||
arch.info.install reason=安装原因
|
||||
arch.info.install reason.explicitly installed=明确安装
|
||||
arch.info.install reason.installed as a dependency for another package=作为其他软件包的依赖项安装
|
||||
arch.info.install script=安装脚本
|
||||
arch.info.install script.no=no
|
||||
arch.info.installed files=已安装文件
|
||||
arch.info.installed size=已安装大小
|
||||
arch.info.last_modified=上次修改
|
||||
arch.info.license=许可证
|
||||
arch.info.licenses=许可证
|
||||
arch.info.licenses.custom=自定义
|
||||
arch.info.name=名称
|
||||
arch.info.optdepends=可选依赖项
|
||||
arch.info.optional deps=可选依赖项
|
||||
arch.info.optional for=可选用于
|
||||
arch.info.options=选项
|
||||
arch.info.packager=打包者
|
||||
arch.info.packager.unknown packager=未知的打包者
|
||||
arch.info.pkgdesc=描述
|
||||
arch.info.pkgname=名称
|
||||
arch.info.pkgrel=版本号
|
||||
arch.info.pkgver=版本
|
||||
arch.info.provides=提供
|
||||
arch.info.replaces=替代
|
||||
arch.info.required by=被其他软件包需要
|
||||
arch.info.source=来源
|
||||
arch.info.url=URL
|
||||
arch.info.validated by=验证者
|
||||
arch.info.validated by.signature=签名
|
||||
arch.info.validpgpkeys=有效的 PGP 密钥
|
||||
arch.info.version=版本
|
||||
arch.install.aur.root_error.body=不允许以 root 用户身份安装、升级或降级软件包
|
||||
arch.install.aur.root_error.title=不允许的操作
|
||||
arch.install.aur.unknown_key.body=要继续 {} 的安装，需要信任以下公钥 {}
|
||||
arch.install.aur.unknown_key.title=需要的公钥
|
||||
arch.install.conflict.popup.body=应用程序 {} 冲突。您必须卸载一个以安装另一个。继续吗？
|
||||
arch.install.conflict.popup.title=检测到冲突
|
||||
arch.install.dep_not_found.body.l1=在仓库或 AUR 中未找到所需的依赖项 {dep}{source}。
|
||||
arch.install.dep_not_found.body.l2=可能是软件包数据库同步问题。
|
||||
arch.install.dep_not_found.body.l3=操作已取消。
|
||||
arch.install.dep_not_found.title=未找到依赖项
|
||||
arch.install.dependency.install=正在安装软件包依赖项 {}
|
||||
arch.install.dependency.install.error=无法安装依赖软件包：{}。已中止 {} 的安装。
|
||||
arch.install.error.conflicting_files=软件包 {} 要求覆盖其他已安装软件包的文件
|
||||
arch.install.error.conflicting_files.proceed=允许
|
||||
arch.install.error.conflicting_files.stop=取消安装
|
||||
arch.install.optdep.error=无法安装可选软件包：{}
|
||||
arch.install.optdeps.request.body=检查下面的可选关联软件包，选择要安装的软件包
|
||||
arch.install.optdeps.request.success={pkg} 已成功安装！
|
||||
arch.install.optdeps.request.title=可选依赖项
|
||||
arch.installing.package=正在安装 {} 软件包
|
||||
arch.checking_unnecessary_deps=检查是否有不再需要的软件包
|
||||
arch.makepkg.optimizing=优化编译
|
||||
arch.missing_deps.body=将安装以下依赖项({deps})
|
||||
arch.missing_deps.title=缺少的依赖项
|
||||
arch.missing_deps_found={} 的缺少依赖项
|
||||
arch.mthread_downloaded.error.cache_dir=无法创建缓存目录 {}
|
||||
arch.mthread_downloaded.error.cancelled=操作已取消
|
||||
arch.optdeps.checking=检查 {} 的可选依赖项
|
||||
arch.package.requires_rebuild=需要重新安装
|
||||
arch.providers=提供者
|
||||
arch.substatus.conflicts=检查冲突
|
||||
arch.substatus.disk_space=检查可用磁盘空间
|
||||
arch.substatus.integrity=检查软件包完整性
|
||||
arch.substatus.keyring=检查密钥环
|
||||
arch.substatus.loading_files=加载软件包文件
|
||||
arch.substatus.pre_hooks=运行事务前挂钩
|
||||
arch.substatus.retrieve_pkgs=检索软件包
|
||||
arch.sync.dep_breakage.reason={} 需要 {}
|
||||
arch.sync_databases.substatus=同步软件包数据库
|
||||
arch.sync_databases.substatus.error=无法同步软件包数据库
|
||||
arch.sync_databases.substatus.synchronized=已同步
|
||||
arch.task.aur.index.status=生成本地 AUR 索引
|
||||
arch.task.aur.index.substatus.checking=检查更新
|
||||
arch.task.aur.index.substatus.download=正在下载 AUR 索引
|
||||
arch.task.aur.index.substatus.error.download=下载索引时连接错误
|
||||
arch.task.aur.index.substatus.error.no_data=错误：空索引
|
||||
arch.task.aur.index.substatus.gen_index=生成索引
|
||||
arch.task.checking_settings=检查设置
|
||||
arch.task.disabled=已禁用
|
||||
arch.task.disk_cache=索引化软件包数据
|
||||
arch.task.disk_cache.checking=检查索引
|
||||
arch.task.disk_cache.indexed=已索引
|
||||
arch.task.disk_cache.indexing=正在索引
|
||||
arch.task.disk_cache.reading_files=正在读取文件
|
||||
arch.task.disk_cache.waiting_aur_index=等待 {}
|
||||
arch.task.mirrors=刷新镜像
|
||||
arch.task.mirrors.cached=已刷新
|
||||
arch.task.optimizing=优化 {}
|
||||
arch.task.sync_sb.status=更新 {}
|
||||
arch.uninstall.clean_cached.error=无法删除磁盘上找到的旧 {} 版本
|
||||
arch.uninstall.clean_cached.substatus=正在从磁盘中删除旧版本
|
||||
arch.uninstall.error.hard_dep_in_hold=无法卸载 {}，因为它的某个依赖关系被标记为 "InHold"
|
||||
arch.uninstall.required_by=以下软件包({no})依赖于 {pkgs} 以正常工作
|
||||
arch.uninstall.required_by.warn=必须卸载它们以便继续
|
||||
arch.uninstall.unnecessary.all=将卸载以下 {} 软件包
|
||||
arch.uninstall.unnecessary.cancel=保留
|
||||
arch.uninstall.unnecessary.l1=软件包已成功卸载！
|
||||
arch.uninstall.unnecessary.l2=以下软件包似乎不再需要
|
||||
arch.uninstall.unnecessary.proceed=卸载
|
||||
arch.uninstalling.conflict=正在卸载冲突的软件包
|
||||
arch.uninstalling.conflict.fail=无法卸载冲突的软件包：{}
|
||||
arch.update.disabled.tooltip=此软件包只能通过 "快速系统升级" 操作升级
|
||||
arch.update_summary.conflict_between={} 与 {} 冲突
|
||||
arch.update_summary.to_install.dep_conflict={} 与依赖项 {} 冲突
|
||||
arch.update_summary.to_update.conflicts_dep={} 与 {} 的依赖项冲突
|
||||
arch.update_summary.to_update.dep_conflicts={} 的依赖项与 {} 冲突
|
||||
arch.upgrade.caching_pkgs_data=正在缓存更新数据
|
||||
arch.upgrade.error.conflicting_files=正在升级的一些软件包要求覆盖其他已安装软件包的文件
|
||||
arch.upgrade.error.dep_breakage=检测到一些依赖关系破坏问题
|
||||
arch.upgrade.error.dep_breakage.item={} 的新版本破坏了已安装版本的 {} 依赖关系
|
||||
arch.upgrade.error.dep_breakage.proceed=仍要继续
|
||||
arch.upgrade.error.dep_breakage.stop=取消升级
|
||||
arch.upgrade.conflicting_files.proceed=允许并继续
|
||||
arch.upgrade.conflicting_files.stop=取消升级
|
||||
arch.upgrade.fail=软件包 {} 升级失败
|
||||
arch.upgrade.mthreaddownload.fail=无法下载所有升级软件包
|
||||
arch.upgrade.success=软件包 {} 升级成功
|
||||
arch.upgrade.upgrade_aur_pkgs=正在升级 AUR 软件包
|
||||
arch.upgrade.upgrade_repo_pkgs=正在升级来自仓库的软件包
|
||||
arch.warning.disabled={} 似乎未安装。无法管理 Arch / AUR 软件包。
|
||||
arch.warning.aur_missing_dep={} 似乎未安装。无法管理 AUR 软件包。
|
||||
arch_repo.history.1_version=版本
|
||||
arch_repo.history.2_release=发布
|
||||
arch_repo.history.3_date=日期
|
||||
aur.history.1_version=版本
|
||||
aur.history.2_release=发布
|
||||
aur.history.3_date=日期
|
||||
category.orphan=孤儿
|
||||
category.out_of_date=过时
|
||||
gem.arch.info=适用于基于 Arch Linux 的发行版的软件包
|
||||
gem.arch.label=Arch
|
||||
gem.arch.type.arch_repo.label=Arch - 仓库
|
||||
gem.arch.type.aur.label=Arch - AUR
|
||||
@@ -1,150 +0,0 @@
|
||||
from typing import Dict, Set, Tuple, List, Collection, Optional
|
||||
|
||||
|
||||
def __add_dep_to_sort(pkgname: str, pkgs_data: Dict[str, dict], sorted_names: dict, not_sorted: Set[str],
|
||||
provided_map: Dict[str, str]):
|
||||
idx = sorted_names.get(pkgname)
|
||||
|
||||
if idx is not None:
|
||||
return idx
|
||||
else:
|
||||
idx = len(sorted_names)
|
||||
sorted_names[pkgname] = idx
|
||||
|
||||
for dep in pkgs_data[pkgname]['d']:
|
||||
dep_idx = sorted_names.get(dep)
|
||||
|
||||
if dep_idx is not None and dep_idx + 1 > idx:
|
||||
idx = dep_idx + 1
|
||||
else:
|
||||
real_dep = provided_map.get(dep) # gets the real package name instead of the provided one
|
||||
|
||||
if not real_dep or real_dep not in pkgs_data:
|
||||
continue # it means this depends does not belong to the sorting context
|
||||
else:
|
||||
dep_idx = sorted_names.get(real_dep)
|
||||
|
||||
if dep_idx is not None and dep_idx + 1 > idx:
|
||||
idx = dep_idx + 1
|
||||
else:
|
||||
dep_idx = __add_dep_to_sort(real_dep, pkgs_data, sorted_names, not_sorted, provided_map)
|
||||
if dep_idx + 1 > idx:
|
||||
idx = dep_idx + 1
|
||||
|
||||
sorted_names[pkgname] = idx
|
||||
return idx
|
||||
|
||||
|
||||
def sort(pkgs: Collection[str], pkgs_data: Dict[str, dict], provided_map: Optional[Dict[str, Set[str]]] = None) -> List[Tuple[str, str]]:
|
||||
sorted_list, sorted_names, not_sorted = [], set(), set()
|
||||
all_provided = {**provided_map} if provided_map else {}
|
||||
|
||||
# adding all packages with no dependencies first
|
||||
for pkgname in pkgs:
|
||||
data = pkgs_data[pkgname]
|
||||
|
||||
if data['p']: # adding providers not mapped to the sorting context
|
||||
for p in data['p']:
|
||||
if p not in all_provided:
|
||||
all_provided[p] = {pkgname}
|
||||
|
||||
if not data['d']:
|
||||
sorted_list.append(pkgname)
|
||||
sorted_names.add(pkgname)
|
||||
else:
|
||||
not_sorted.add(pkgname)
|
||||
|
||||
deps_map, not_deps_available = {}, set()
|
||||
for pkg in not_sorted: # generating a dependency map with only the dependencies among the informed packages
|
||||
pkgsdeps = set()
|
||||
data = pkgs_data[pkg]
|
||||
for dep in data['d']:
|
||||
providers = all_provided.get(dep)
|
||||
|
||||
if providers:
|
||||
for p in providers:
|
||||
if p in pkgs:
|
||||
pkgsdeps.add(p)
|
||||
|
||||
if pkgsdeps:
|
||||
deps_map[pkg] = pkgsdeps
|
||||
else:
|
||||
not_deps_available.add(pkg)
|
||||
sorted_list.append(pkg)
|
||||
sorted_names.add(pkg)
|
||||
|
||||
for pkg in not_deps_available: # removing from not_sorted
|
||||
not_sorted.remove(pkg)
|
||||
|
||||
while not_sorted:
|
||||
sorted_in_round = set()
|
||||
|
||||
for pkg in not_sorted:
|
||||
idx = _index_pkg(pkg, sorted_list, sorted_names, deps_map, ignore_not_sorted=False)
|
||||
|
||||
if idx >= 0:
|
||||
sorted_in_round.add(pkg)
|
||||
sorted_names.add(pkg)
|
||||
sorted_list.insert(idx, pkg)
|
||||
|
||||
for pkg in sorted_in_round:
|
||||
not_sorted.remove(pkg)
|
||||
|
||||
if not_sorted and not sorted_in_round: # it means there are cyclic deps
|
||||
break
|
||||
|
||||
if not_sorted: # it means there are cyclic deps
|
||||
# filtering deps already mapped
|
||||
for pkg in not_sorted:
|
||||
deps_map[pkg] = deps_map[pkg].difference(sorted_names)
|
||||
|
||||
dep_lvl_map = {} # holds the diff between the number of dependents per package and its dependencies
|
||||
for pkg in not_sorted:
|
||||
dependents = 0
|
||||
for pkg2 in not_sorted:
|
||||
if pkg != pkg2 and pkg in deps_map[pkg2]:
|
||||
dependents += 1
|
||||
|
||||
dep_lvl_map[pkg] = dependents - len(deps_map[pkg])
|
||||
|
||||
sorted_by_less_deps = [*not_sorted]
|
||||
sorted_by_less_deps.sort(key=lambda o: dep_lvl_map[o], reverse=True) # sorting by higher dep level
|
||||
|
||||
for pkg in sorted_by_less_deps:
|
||||
idx = _index_pkg(pkg, sorted_list, sorted_names, deps_map, ignore_not_sorted=True)
|
||||
sorted_names.add(pkg)
|
||||
sorted_list.insert(idx, pkg)
|
||||
|
||||
# putting arch pkgs in the end:
|
||||
aur_pkgs = None
|
||||
res = []
|
||||
|
||||
for name in sorted_list:
|
||||
repo = pkgs_data[name]['r']
|
||||
if repo == 'aur':
|
||||
if not aur_pkgs:
|
||||
aur_pkgs = []
|
||||
|
||||
aur_pkgs.append((name, 'aur'))
|
||||
else:
|
||||
res.append((name, repo))
|
||||
|
||||
if aur_pkgs:
|
||||
res.extend(aur_pkgs)
|
||||
|
||||
return res
|
||||
|
||||
|
||||
def _index_pkg(name: str, sorted_list: List[str], sorted_names: Set[str], deps_map: Dict[str, Set[str]], ignore_not_sorted: bool) -> int:
|
||||
deps_to_check_idx = set()
|
||||
for dep in deps_map[name]:
|
||||
if dep in sorted_names:
|
||||
deps_to_check_idx.add(dep)
|
||||
elif not ignore_not_sorted:
|
||||
return -1
|
||||
|
||||
if not deps_to_check_idx:
|
||||
return len(sorted_list)
|
||||
else:
|
||||
idxs = {sorted_list.index(dep) for dep in deps_to_check_idx}
|
||||
return max(idxs) + 1
|
||||
@@ -1,8 +0,0 @@
|
||||
from typing import Optional, Tuple
|
||||
|
||||
from bauh.commons.system import execute
|
||||
|
||||
|
||||
def mkdir(dir_path: str, parent: bool = True, custom_user: Optional[str] = None) -> Tuple[bool, Optional[str]]:
|
||||
code, output = execute(f'mkdir {"-p " if parent else ""}"{dir_path}"', shell=True, custom_user=custom_user)
|
||||
return code == 0, output
|
||||
@@ -1,209 +0,0 @@
|
||||
import os
|
||||
import traceback
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from logging import Logger
|
||||
from pathlib import Path
|
||||
from threading import Thread
|
||||
from typing import Optional, Dict
|
||||
|
||||
from bauh.api.abstract.handler import TaskManager
|
||||
from bauh.api.abstract.model import SuggestionPriority
|
||||
from bauh.api.http import HttpClient
|
||||
from bauh.commons.boot import CreateConfigFile
|
||||
from bauh.gems.arch import ARCH_CACHE_DIR, get_icon_path
|
||||
from bauh.view.util.translation import I18n
|
||||
from bauh.commons.suggestions import parse
|
||||
|
||||
|
||||
class RepositorySuggestionsDownloader(Thread):
|
||||
|
||||
_file_suggestions: Optional[str] = None
|
||||
_file_suggestions_ts: Optional[str] = None
|
||||
|
||||
@classmethod
|
||||
def file_suggestions(cls) -> str:
|
||||
if cls._file_suggestions is None:
|
||||
cls._file_suggestions = f'{ARCH_CACHE_DIR}/suggestions.txt'
|
||||
|
||||
return cls._file_suggestions
|
||||
|
||||
@classmethod
|
||||
def file_suggestions_timestamp(cls) -> str:
|
||||
if cls._file_suggestions_ts is None:
|
||||
cls._file_suggestions_ts = f'{cls.file_suggestions()}.ts'
|
||||
|
||||
return cls._file_suggestions_ts
|
||||
|
||||
def __init__(self, logger: Logger, http_client: HttpClient, i18n: I18n,
|
||||
create_config: Optional[CreateConfigFile] = None, file_url: Optional[str] = None):
|
||||
super(RepositorySuggestionsDownloader, self).__init__()
|
||||
self._log = logger
|
||||
self.i18n = i18n
|
||||
self.http_client = http_client
|
||||
self._taskman: Optional[TaskManager] = None
|
||||
self.create_config = create_config
|
||||
self._file_url = file_url if file_url else 'https://raw.githubusercontent.com/vinifmor/bauh-files' \
|
||||
'/master/arch/suggestions.txt'
|
||||
self.task_id = 'arch.suggs'
|
||||
|
||||
def register_task(self, taskman: Optional[TaskManager]):
|
||||
self._taskman = taskman
|
||||
if taskman:
|
||||
self._taskman.register_task(id_=self.task_id, label=self.i18n['task.download_suggestions'],
|
||||
icon_path=get_icon_path())
|
||||
|
||||
@property
|
||||
def taskman(self) -> TaskManager:
|
||||
if self._taskman is None:
|
||||
self._taskman = TaskManager()
|
||||
|
||||
return self._taskman
|
||||
|
||||
def should_download(self, arch_config: dict, only_positive_exp: bool = False) -> bool:
|
||||
if not self._file_url:
|
||||
self._log.error("No Arch suggestions file URL defined")
|
||||
return False
|
||||
|
||||
if self._file_url.startswith('/'):
|
||||
return False
|
||||
|
||||
try:
|
||||
exp_hours = int(arch_config['suggestions_exp'])
|
||||
except ValueError:
|
||||
self._log.error(f"The Arch configuration property 'suggestions_exp' has a non int value set: "
|
||||
f"{arch_config['suggestions']['expiration']}")
|
||||
return not only_positive_exp
|
||||
|
||||
if exp_hours <= 0:
|
||||
self._log.info("Suggestions cache is disabled")
|
||||
return not only_positive_exp
|
||||
|
||||
if not os.path.exists(self.file_suggestions()):
|
||||
self._log.info(f"'{self.file_suggestions()}' not found. It must be downloaded")
|
||||
return True
|
||||
|
||||
if not os.path.exists(self.file_suggestions_timestamp()):
|
||||
self._log.info(f"'{self.file_suggestions()}' not found. The suggestions file must be downloaded.")
|
||||
return True
|
||||
|
||||
with open(self.file_suggestions_timestamp()) as f:
|
||||
timestamp_str = f.read()
|
||||
|
||||
try:
|
||||
suggestions_timestamp = datetime.fromtimestamp(float(timestamp_str), tz=timezone.utc)
|
||||
except Exception:
|
||||
self._log.error(f'Could not parse the Arch cached suggestions timestamp: {timestamp_str}')
|
||||
traceback.print_exc()
|
||||
return True
|
||||
|
||||
update = suggestions_timestamp + timedelta(hours=exp_hours) <= datetime.now(timezone.utc)
|
||||
|
||||
if update:
|
||||
self._log.info("The cached suggestions file is no longer valid")
|
||||
else:
|
||||
self._log.info("The cached suggestions file is up-to-date")
|
||||
|
||||
return update
|
||||
|
||||
def _save(self, text: str, timestamp: float):
|
||||
self._log.info(f"Caching suggestions to '{self.file_suggestions()}'")
|
||||
|
||||
cache_dir = os.path.dirname(self.file_suggestions())
|
||||
|
||||
try:
|
||||
Path(cache_dir).mkdir(parents=True, exist_ok=True)
|
||||
cache_dir_ok = True
|
||||
except OSError:
|
||||
self._log.error(f"Could not create cache directory '{cache_dir}'")
|
||||
traceback.print_exc()
|
||||
cache_dir_ok = False
|
||||
|
||||
if cache_dir_ok:
|
||||
try:
|
||||
with open(self.file_suggestions(), 'w+') as f:
|
||||
f.write(text)
|
||||
except Exception:
|
||||
self._log.error(f"An exception happened while writing the file '{self.file_suggestions()}'")
|
||||
traceback.print_exc()
|
||||
|
||||
try:
|
||||
with open(self.file_suggestions_timestamp(), 'w+') as f:
|
||||
f.write(str(timestamp))
|
||||
except Exception:
|
||||
self._log.error(f"An exception happened while writing the file '{self.file_suggestions_timestamp()}'")
|
||||
traceback.print_exc()
|
||||
|
||||
def read_cached(self, custom_file: Optional[str] = None) -> Optional[Dict[str, SuggestionPriority]]:
|
||||
if custom_file:
|
||||
file_path, log_ref = custom_file, 'local'
|
||||
else:
|
||||
file_path, log_ref = self.file_suggestions(), 'cached'
|
||||
|
||||
self._log.info(f"Reading {log_ref} Arch suggestions file '{file_path}'")
|
||||
|
||||
try:
|
||||
with open(file_path) as f:
|
||||
sugs_str = f.read()
|
||||
except FileNotFoundError:
|
||||
self._log.warning(f"{log_ref.capitalize()} suggestions file does not exist ({file_path})")
|
||||
return
|
||||
|
||||
if not sugs_str:
|
||||
self._log.warning(f"{log_ref.capitalize()} suggestions file '{file_path}' is empty")
|
||||
return
|
||||
|
||||
return parse(sugs_str, self._log, 'Arch')
|
||||
|
||||
def download(self) -> Optional[Dict[str, SuggestionPriority]]:
|
||||
self.taskman.update_progress(self.task_id, progress=1, substatus=None)
|
||||
|
||||
self._log.info(f"Downloading suggestions from {self._file_url}")
|
||||
res = self.http_client.get(self._file_url)
|
||||
|
||||
suggestions = None
|
||||
if res.status_code == 200 and res.text:
|
||||
self.taskman.update_progress(self.task_id, progress=50, substatus=None)
|
||||
suggestions = parse(res.text, self._log, 'Arch')
|
||||
|
||||
if suggestions:
|
||||
self._save(text=res.text, timestamp=datetime.now(timezone.utc).timestamp())
|
||||
else:
|
||||
self._log.warning(f"Could not parse any Arch suggestion from {self._file_suggestions_ts}")
|
||||
else:
|
||||
self._log.warning(f"Could not retrieve Arch suggestions. "
|
||||
f"Response (status={res.status_code}, text={res.text})")
|
||||
|
||||
self.taskman.update_progress(self.task_id, progress=100, substatus=None)
|
||||
self.taskman.finish_task(self.task_id)
|
||||
return suggestions
|
||||
|
||||
def read(self, arch_config: dict) -> Optional[Dict[str, int]]:
|
||||
if self._file_url:
|
||||
if self.is_custom_local_file_mapped():
|
||||
return self.read_cached(custom_file=self._file_url)
|
||||
|
||||
if self.should_download(arch_config=arch_config):
|
||||
return self.download()
|
||||
|
||||
return self.read_cached()
|
||||
|
||||
def is_custom_local_file_mapped(self) -> bool:
|
||||
return self._file_url and self._file_url.startswith('/')
|
||||
|
||||
def run(self):
|
||||
if self.create_config:
|
||||
if self.create_config.is_alive():
|
||||
self.taskman.update_progress(self.task_id, 0,
|
||||
self.i18n['task.waiting_task'].format(self.create_config.task_name))
|
||||
self.create_config.join()
|
||||
|
||||
if not self.should_download(arch_config=self.create_config.config, only_positive_exp=False):
|
||||
self.taskman.update_progress(self.task_id, 100, self.i18n['task.canceled'])
|
||||
self.taskman.finish_task(self.task_id)
|
||||
return
|
||||
|
||||
self.download()
|
||||
else:
|
||||
self._log.error(f"No {CreateConfigFile.__class__.__name__} instance set. Aborting..")
|
||||
self.taskman.update_progress(self.task_id, 100, self.i18n['error'])
|
||||
self.taskman.finish_task(self.task_id)
|
||||
@@ -1,911 +0,0 @@
|
||||
import logging
|
||||
import time
|
||||
import traceback
|
||||
from threading import Thread
|
||||
from typing import Dict, Set, List, Tuple, Iterable, Optional, Any
|
||||
|
||||
from bauh.api.abstract.controller import UpgradeRequirements, UpgradeRequirement
|
||||
from bauh.api.abstract.handler import ProcessWatcher
|
||||
from bauh.gems.arch import pacman, sorting
|
||||
from bauh.gems.arch.aur import AURClient
|
||||
from bauh.gems.arch.dependencies import DependenciesAnalyser
|
||||
from bauh.gems.arch.exceptions import PackageNotFoundException
|
||||
from bauh.gems.arch.model import ArchPackage
|
||||
from bauh.gems.arch.pacman import RE_DEP_OPERATORS
|
||||
from bauh.commons.version_util import match_required_version
|
||||
from bauh.view.util.translation import I18n
|
||||
|
||||
|
||||
class UpdateRequirementsContext:
|
||||
|
||||
def __init__(self, to_update: Dict[str, ArchPackage], repo_to_update: Dict[str, ArchPackage],
|
||||
aur_to_update: Dict[str, ArchPackage], repo_to_install: Dict[str, ArchPackage],
|
||||
aur_to_install: Dict[str, ArchPackage], to_install: Dict[str, ArchPackage],
|
||||
pkgs_data: Dict[str, dict], cannot_upgrade: Dict[str, UpgradeRequirement],
|
||||
to_remove: Dict[str, UpgradeRequirement], installed: Dict[str, str],
|
||||
provided_map: Dict[str, Set[str]], aur_index: Set[str], arch_config: dict,
|
||||
remote_provided_map: Dict[str, Set[str]], remote_repo_map: Dict[str, str],
|
||||
root_password: Optional[str], aur_supported: bool):
|
||||
self.to_update = to_update
|
||||
self.repo_to_update = repo_to_update
|
||||
self.aur_to_update = aur_to_update
|
||||
self.repo_to_install = repo_to_install
|
||||
self.aur_to_install = aur_to_install
|
||||
self.pkgs_data = pkgs_data
|
||||
self.cannot_upgrade = cannot_upgrade
|
||||
self.root_password = root_password
|
||||
self.installed = installed
|
||||
self.provided_map = provided_map
|
||||
self.to_remove = to_remove
|
||||
self.to_install = to_install
|
||||
self.aur_index = aur_index
|
||||
self.arch_config = arch_config
|
||||
self.remote_provided_map = remote_provided_map
|
||||
self.remote_repo_map = remote_repo_map
|
||||
self.aur_supported = aur_supported
|
||||
|
||||
def update_provided_map(self, update: Dict[str, Set[str]]):
|
||||
if self.provided_map is None:
|
||||
self.provided_map = {**update}
|
||||
else:
|
||||
for provider, provided in update.items():
|
||||
provided_set = self.provided_map.get(provider)
|
||||
|
||||
if provided_set is None:
|
||||
provided_set = set()
|
||||
self.provided_map[provider] = provided_set
|
||||
|
||||
provided_set.update(provided)
|
||||
|
||||
def add_to_provided_map(self, provider: str, provided: str):
|
||||
if self.provided_map is None:
|
||||
self.provided_map = dict()
|
||||
|
||||
provided_set = self.provided_map.get(provider)
|
||||
|
||||
if provided_set is None:
|
||||
provided_set = set()
|
||||
self.provided_map[provider] = provided_set
|
||||
|
||||
provided_set.add(provided)
|
||||
|
||||
|
||||
class UpdatesSummarizer:
|
||||
|
||||
def __init__(self, aur_client: AURClient, i18n: I18n, logger: logging.Logger, deps_analyser: DependenciesAnalyser, aur_supported: bool, watcher: ProcessWatcher):
|
||||
self.aur_client = aur_client
|
||||
self.i18n = i18n
|
||||
self.logger = logger
|
||||
self.watcher = watcher
|
||||
self.deps_analyser = deps_analyser
|
||||
self.aur_supported = aur_supported
|
||||
|
||||
def _fill_aur_pkg_update_data(self, pkg: ArchPackage, output: dict):
|
||||
output[pkg.name] = self.aur_client.map_update_data(pkg.get_base_name(), pkg.latest_version)
|
||||
|
||||
def _handle_conflict_both_to_install(self, pkg1: str, pkg2: str, context: UpdateRequirementsContext):
|
||||
for src_pkg in {p for p, data in context.pkgs_data.items() if
|
||||
data['d'] and pkg1 in data['d'] or pkg2 in data['d']}:
|
||||
if src_pkg not in context.cannot_upgrade:
|
||||
reason = self.i18n['arch.update_summary.to_install.dep_conflict'].format(f"'{pkg1}'", f"'{pkg2}'")
|
||||
context.cannot_upgrade[src_pkg] = UpgradeRequirement(context.to_update[src_pkg], reason)
|
||||
|
||||
del context.to_update[src_pkg]
|
||||
|
||||
if src_pkg in context.repo_to_update:
|
||||
del context.repo_to_update[src_pkg]
|
||||
else:
|
||||
del context.aur_to_update[src_pkg]
|
||||
|
||||
del context.pkgs_data[src_pkg]
|
||||
|
||||
for p in (pkg1, pkg2):
|
||||
if p in context.to_install:
|
||||
del context.to_install[p]
|
||||
|
||||
if p in context.repo_to_install:
|
||||
del context.repo_to_install[p]
|
||||
else:
|
||||
del context.aur_to_install[p]
|
||||
|
||||
def _handle_conflict_to_update_and_to_install(self, pkg1: str, pkg2: str, pkg1_to_install: bool, context: UpdateRequirementsContext):
|
||||
to_install, to_update = (pkg1, pkg2) if pkg1_to_install else (pkg2, pkg1)
|
||||
to_install_srcs = {p for p, data in context.pkgs_data.items() if data['d'] and to_install in data['d']}
|
||||
|
||||
if to_update not in context.cannot_upgrade:
|
||||
srcs_str = ', '.join(("'{}'".format(p) for p in to_install_srcs))
|
||||
reason = self.i18n['arch.update_summary.to_update.conflicts_dep'].format("'{}'".format(to_install),
|
||||
srcs_str)
|
||||
context.cannot_upgrade[to_install] = UpgradeRequirement(context.to_update[to_update], reason)
|
||||
|
||||
if to_update in context.to_update:
|
||||
del context.to_update[to_update]
|
||||
|
||||
for src_pkg in to_install_srcs:
|
||||
src_to_install = src_pkg in context.to_install
|
||||
pkg = context.to_install[src_pkg] if src_to_install else context.to_update[src_pkg]
|
||||
if src_pkg not in context.cannot_upgrade:
|
||||
reason = self.i18n['arch.update_summary.to_update.dep_conflicts'].format("'{}'".format(to_install),
|
||||
"'{}'".format(to_update))
|
||||
context.cannot_upgrade[src_pkg] = UpgradeRequirement(pkg, reason)
|
||||
|
||||
if src_to_install:
|
||||
del context.to_install[src_pkg]
|
||||
|
||||
if src_pkg in context.repo_to_install:
|
||||
del context.repo_to_install[src_pkg]
|
||||
else:
|
||||
del context.aur_to_install[src_pkg]
|
||||
else:
|
||||
del context.to_update[src_pkg]
|
||||
|
||||
if src_pkg in context.repo_to_update:
|
||||
del context.repo_to_update[src_pkg]
|
||||
else:
|
||||
del context.aur_to_update[src_pkg]
|
||||
|
||||
del context.pkgs_data[src_pkg]
|
||||
|
||||
if to_install in context.to_install:
|
||||
del context.to_install[to_install]
|
||||
|
||||
def _handle_conflict_both_to_update(self, pkg1: str, pkg2: str, context: UpdateRequirementsContext):
|
||||
if pkg1 not in context.cannot_upgrade:
|
||||
reason = f"{self.i18n['arch.info.conflicts with'].capitalize()} '{pkg2}'"
|
||||
context.cannot_upgrade[pkg1] = UpgradeRequirement(pkg=context.to_update[pkg1], reason=reason)
|
||||
|
||||
if pkg2 not in context.cannot_upgrade:
|
||||
reason = f"{self.i18n['arch.info.conflicts with'].capitalize()} '{pkg1}'"
|
||||
context.cannot_upgrade[pkg2] = UpgradeRequirement(pkg=context.to_update[pkg2], reason=reason)
|
||||
|
||||
for p in (pkg1, pkg2):
|
||||
if p in context.to_update:
|
||||
del context.to_update[p]
|
||||
|
||||
if p in context.repo_to_update:
|
||||
del context.repo_to_update[p]
|
||||
else:
|
||||
del context.aur_to_update[p]
|
||||
|
||||
def _map_virtual_providers(self, providers: Dict[str, Set[str]], installed: Dict[str, str]) -> Dict[str, Set[str]]:
|
||||
ti = time.time()
|
||||
virtual_version = dict()
|
||||
for provider in providers:
|
||||
name_version = provider.split("=")
|
||||
if len(name_version) == 2 and name_version[0] not in installed:
|
||||
versions = virtual_version.get(name_version[0])
|
||||
|
||||
if not versions:
|
||||
versions = set()
|
||||
virtual_version[name_version[0]] = versions
|
||||
|
||||
versions.add(name_version[1])
|
||||
tf = time.time()
|
||||
self.logger.info(f"Took {tf - ti:.6f} seconds to map virtual providers of {len(providers)} packages")
|
||||
return virtual_version
|
||||
|
||||
def _map_conflicts(self, data: Dict[str, Dict[str, Any]], providers: Dict[str, Set[str]],
|
||||
versions: Dict[str, str]) -> Tuple[Dict[str, str], Dict[str, str]]:
|
||||
"""
|
||||
Parameters
|
||||
pkgs_data: a dict mapping the packages whose conflicts need to be analyzed to their data
|
||||
providers: a dict mapping the available providers on the context (installed and to be installed) to their
|
||||
respective package
|
||||
versions: a dict mapping the package name to it's version (the updated or to be installed version)
|
||||
Return
|
||||
a tuple with two dictionaries:
|
||||
- first: containing all conflicts
|
||||
- second: containing mutual conflicts
|
||||
"""
|
||||
virtual_providers = self._map_virtual_providers(providers, versions)
|
||||
|
||||
root_conflict = {}
|
||||
mutual_conflicts = {}
|
||||
|
||||
for pkg_name, data in data.items():
|
||||
if data['c']:
|
||||
for c in data['c']:
|
||||
if c:
|
||||
name_op_exp = DependenciesAnalyser.re_dep_operator().split(c)
|
||||
conflict_name = name_op_exp[0]
|
||||
|
||||
if conflict_name != pkg_name:
|
||||
conflict_providers = providers.get(conflict_name)
|
||||
if conflict_providers: # it means the conflict name matches a provided package
|
||||
checked_conflicts = set()
|
||||
|
||||
if len(name_op_exp) == 1: # if no expression is provided, add all providers
|
||||
checked_conflicts.update((p for p in conflict_providers if p != pkg_name))
|
||||
else:
|
||||
virtual_versions = virtual_providers.get(conflict_name)
|
||||
|
||||
if virtual_versions:
|
||||
# it means it's a virtual package
|
||||
# (e.g: 'xorg-server' provides a virtual package called 'x-server')
|
||||
for pversion in virtual_versions:
|
||||
if match_required_version(pversion, name_op_exp[1], name_op_exp[2]):
|
||||
# read the packages providing this specific virtual package version
|
||||
real_providers = providers.get(f"{conflict_name}={pversion}")
|
||||
|
||||
if real_providers:
|
||||
checked_conflicts.update(p for p in real_providers if p != pkg_name)
|
||||
|
||||
else:
|
||||
for provider in conflict_providers:
|
||||
if provider != pkg_name:
|
||||
provider_version = versions.get(provider)
|
||||
if provider_version and match_required_version(provider_version,
|
||||
name_op_exp[1],
|
||||
name_op_exp[2]):
|
||||
checked_conflicts.add(provider)
|
||||
|
||||
for provider in checked_conflicts:
|
||||
root_conflict[provider] = pkg_name
|
||||
|
||||
if (pkg_name, provider) in root_conflict.items():
|
||||
mutual_conflicts[provider] = pkg_name
|
||||
|
||||
return root_conflict, mutual_conflicts
|
||||
|
||||
def _handle_mutual_conflicts(self, mutual_conflicts: Dict[str, str], all_conflicts: Dict[str, str],
|
||||
context: UpdateRequirementsContext):
|
||||
for pkg1, pkg2 in mutual_conflicts.items():
|
||||
pkg1_to_install = pkg1 in context.to_install
|
||||
pkg2_to_install = pkg2 in context.to_install
|
||||
|
||||
if pkg1_to_install and pkg2_to_install:
|
||||
# remove both from to install and mark their source packages as 'cannot_update'
|
||||
self._handle_conflict_both_to_install(pkg1, pkg2, context)
|
||||
elif (pkg1_to_install and not pkg2_to_install) or (not pkg1_to_install and pkg2_to_install):
|
||||
self._handle_conflict_to_update_and_to_install(pkg1, pkg2, pkg1_to_install, context)
|
||||
else:
|
||||
# adding both to the 'cannot update' list
|
||||
self._handle_conflict_both_to_update(pkg1, pkg2, context)
|
||||
|
||||
# removing conflicting packages from the packages selected to upgrade
|
||||
for pkg1, pkg2 in mutual_conflicts.items():
|
||||
for pkg_name in (pkg1, pkg2):
|
||||
if pkg_name in context.pkgs_data:
|
||||
if context.pkgs_data[pkg_name].get('c'):
|
||||
for c in context.pkgs_data[pkg_name]['c']:
|
||||
# source = provided_map[c]
|
||||
if c in all_conflicts:
|
||||
del all_conflicts[c]
|
||||
|
||||
del context.pkgs_data[pkg_name]
|
||||
|
||||
def _fill_conflicts(self, context: UpdateRequirementsContext, blacklist: Optional[Iterable[str]] = None):
|
||||
self.logger.info("Checking conflicts")
|
||||
|
||||
conflicts, mutual_conflicts = self._map_conflicts(data=context.pkgs_data,
|
||||
providers=context.provided_map,
|
||||
versions=context.installed)
|
||||
|
||||
if mutual_conflicts:
|
||||
self._handle_mutual_conflicts(mutual_conflicts, conflicts, context)
|
||||
|
||||
if conflicts:
|
||||
for conflict_name, source_name in conflicts.items():
|
||||
if conflict_name not in context.to_remove and (not blacklist or conflict_name not in blacklist):
|
||||
if conflict_name in context.to_update:
|
||||
conflict = context.to_update[conflict_name]
|
||||
else:
|
||||
conflict = ArchPackage(name=conflict_name, installed=True, i18n=self.i18n)
|
||||
|
||||
reason = f"{self.i18n['arch.info.conflicts with'].capitalize()} '{source_name}'"
|
||||
context.to_remove[conflict_name] = UpgradeRequirement(conflict, reason)
|
||||
|
||||
def _map_and_add_package(self, pkg_data: Tuple[str, str], idx: int, output: dict):
|
||||
version = None
|
||||
|
||||
if pkg_data[1] == 'aur':
|
||||
try:
|
||||
info = self.aur_client.get_src_info(pkg_data[0])
|
||||
|
||||
if info:
|
||||
version = info.get('pkgver')
|
||||
|
||||
if not version:
|
||||
self.logger.warning("No version declared in SRCINFO of '{}'".format(pkg_data[0]))
|
||||
else:
|
||||
self.logger.warning("Could not retrieve the SRCINFO for '{}'".format(pkg_data[0]))
|
||||
except:
|
||||
self.logger.warning("Could not retrieve the SRCINFO for '{}'".format(pkg_data[0]))
|
||||
else:
|
||||
version = pacman.get_version_for_not_installed(pkg_data[0])
|
||||
|
||||
output[idx] = ArchPackage(name=pkg_data[0], version=version, latest_version=version, repository=pkg_data[1], i18n=self.i18n)
|
||||
|
||||
def _fill_conflicts_to_install(self, context: UpdateRequirementsContext, install_data: Dict[str, Dict[str, Any]]):
|
||||
"""
|
||||
Parameters
|
||||
context: update context
|
||||
install_data: a dict mapping the packages to be installed names by their data
|
||||
"""
|
||||
# to properly fill conflicts considering new packages to be installed:
|
||||
# - the 'context.provided_map' should contain the providers of these new packages
|
||||
# - the 'context.installed' should contain the versions of these new packages
|
||||
provided_map_bkp = {**context.provided_map}
|
||||
self.__fill_provided_map(context=context, pkgs=context.to_install, fill_installed=False)
|
||||
|
||||
# adding the new packages to install as 'installed'
|
||||
for pkg, data in install_data.items():
|
||||
context.installed[pkg] = data["v"]
|
||||
|
||||
self._fill_conflicts(context, context.to_remove.keys())
|
||||
|
||||
# restoring the original data structures
|
||||
context.provided_map = provided_map_bkp
|
||||
|
||||
for pkg in install_data:
|
||||
if pkg in context.installed:
|
||||
del context.installed[pkg]
|
||||
|
||||
def _fill_to_install(self, context: UpdateRequirementsContext) -> bool:
|
||||
ti = time.time()
|
||||
self.logger.info("Discovering updates missing packages")
|
||||
deps_data, deps_checked = {}, set()
|
||||
deps = self.deps_analyser.map_missing_deps(pkgs_data=context.pkgs_data,
|
||||
provided_map=context.provided_map,
|
||||
aur_index=context.aur_index,
|
||||
deps_checked=deps_checked,
|
||||
sort=True,
|
||||
deps_data=deps_data,
|
||||
remote_provided_map=context.remote_provided_map,
|
||||
remote_repo_map=context.remote_repo_map,
|
||||
watcher=self.watcher,
|
||||
automatch_providers=context.arch_config['automatch_providers'],
|
||||
prefer_repository_provider=context.arch_config['prefer_repository_provider'])
|
||||
|
||||
if deps is None:
|
||||
tf = time.time()
|
||||
self.logger.info("It took {0:.2f} seconds to retrieve required upgrade packages".format(tf - ti))
|
||||
return False # the user called the process off
|
||||
|
||||
if deps: # filtering selected packages
|
||||
selected_names = {p for p in context.to_update}
|
||||
deps = [dep for dep in deps if dep[0] not in selected_names]
|
||||
|
||||
if deps:
|
||||
sorted_pkgs = {}
|
||||
aur_to_install_data = {}
|
||||
all_to_install_data = {}
|
||||
|
||||
for idx, dep in enumerate(deps):
|
||||
data = deps_data[dep[0]]
|
||||
pkg = ArchPackage(name=dep[0], version=data['v'], latest_version=data['v'], repository=dep[1],
|
||||
i18n=self.i18n, package_base=data.get('b', dep[0]))
|
||||
sorted_pkgs[idx] = pkg
|
||||
context.to_install[dep[0]] = pkg
|
||||
|
||||
if pkg.repository == 'aur':
|
||||
context.aur_to_install[pkg.name] = pkg
|
||||
aur_to_install_data[pkg.name] = data
|
||||
else:
|
||||
context.repo_to_install[pkg.name] = pkg
|
||||
|
||||
if context.repo_to_install:
|
||||
all_to_install_data.update(pacman.map_updates_data(context.repo_to_install.keys()))
|
||||
|
||||
if aur_to_install_data:
|
||||
all_to_install_data.update(aur_to_install_data)
|
||||
|
||||
if all_to_install_data:
|
||||
context.pkgs_data.update(all_to_install_data)
|
||||
self._fill_conflicts_to_install(context, all_to_install_data)
|
||||
|
||||
if context.to_install:
|
||||
self.__fill_provided_map(context=context, pkgs=context.to_install, fill_installed=False)
|
||||
|
||||
tf = time.time()
|
||||
self.logger.info(f"It took {tf - ti:.2f} seconds to retrieve required upgrade packages")
|
||||
return True
|
||||
|
||||
def __fill_provided_map(self, context: UpdateRequirementsContext, pkgs: Dict[str, ArchPackage],
|
||||
fill_installed: bool = True):
|
||||
if pkgs:
|
||||
ti = time.time()
|
||||
self.logger.info("Filling provided names")
|
||||
|
||||
if not context.installed:
|
||||
context.installed = pacman.map_installed()
|
||||
|
||||
installed_to_ignore = set()
|
||||
|
||||
for pkgname in pkgs:
|
||||
context.add_to_provided_map(pkgname, pkgname)
|
||||
|
||||
if fill_installed:
|
||||
installed_to_ignore.add(pkgname)
|
||||
|
||||
pdata = context.pkgs_data.get(pkgname)
|
||||
if pdata and pdata['p']:
|
||||
context.add_to_provided_map(f"{pkgname}={pdata['v']}", pkgname)
|
||||
|
||||
ver_split = pdata['v'].split('-')
|
||||
|
||||
if len(ver_split) > 1:
|
||||
context.add_to_provided_map(f"{pkgname}={'-'.join(ver_split[0:-1])}", pkgname)
|
||||
|
||||
for p in pdata['p']:
|
||||
context.add_to_provided_map(p, pkgname)
|
||||
split_provided = p.split('=')
|
||||
|
||||
if len(split_provided) > 1 and split_provided[0] != p:
|
||||
context.add_to_provided_map(split_provided[0], pkgname)
|
||||
|
||||
if context.installed and installed_to_ignore: # filling the provided names of the installed
|
||||
installed_to_query = {*context.installed}.difference(installed_to_ignore)
|
||||
|
||||
if installed_to_query:
|
||||
context.update_provided_map(pacman.map_provided(remote=False, pkgs=installed_to_query))
|
||||
|
||||
tf = time.time()
|
||||
self.logger.info("Filling provided names took {0:.2f} seconds".format(tf - ti))
|
||||
|
||||
def __fill_aur_index(self, context: UpdateRequirementsContext):
|
||||
if context.aur_supported:
|
||||
self.logger.info("Loading AUR index")
|
||||
names = self.aur_client.read_index()
|
||||
|
||||
if names:
|
||||
context.aur_index.update(names)
|
||||
self.logger.info("AUR index loaded on the context")
|
||||
|
||||
def _map_requirement(self, pkg: ArchPackage, context: UpdateRequirementsContext,
|
||||
installed_sizes: Optional[Dict[str, float]] = None, to_install: bool = False,
|
||||
to_sync: Set[str] = None) -> UpgradeRequirement:
|
||||
|
||||
requirement = UpgradeRequirement(pkg)
|
||||
|
||||
if pkg.repository != 'aur':
|
||||
pkgdata = context.pkgs_data.get(pkg.name)
|
||||
|
||||
if pkgdata:
|
||||
requirement.required_size = pkgdata['ds']
|
||||
requirement.extra_size = pkgdata['s']
|
||||
|
||||
current_size = installed_sizes.get(pkg.name) if installed_sizes else None
|
||||
|
||||
if current_size is not None and pkgdata['s'] is not None:
|
||||
requirement.extra_size = pkgdata['s'] - current_size
|
||||
|
||||
required_by = set()
|
||||
|
||||
if to_install and to_sync and context.pkgs_data:
|
||||
names = pkgdata.get('p', {pkg.name}) if pkgdata else {pkg.name}
|
||||
to_sync_deps_cache = {}
|
||||
for p in to_sync:
|
||||
if p != pkg.name and p in context.pkgs_data:
|
||||
deps = to_sync_deps_cache.get(p)
|
||||
|
||||
if deps is None:
|
||||
deps = context.pkgs_data[p]['d']
|
||||
|
||||
if deps is None:
|
||||
deps = set()
|
||||
else:
|
||||
deps = {RE_DEP_OPERATORS.split(d)[0] for d in deps}
|
||||
|
||||
to_sync_deps_cache[p] = deps
|
||||
|
||||
if deps:
|
||||
for n in names:
|
||||
if n in deps:
|
||||
required_by.add(p)
|
||||
break
|
||||
|
||||
requirement.reason = f"{self.i18n['arch.info.required by'].capitalize()}: " \
|
||||
f"{','.join(required_by) if required_by else '?'}"
|
||||
|
||||
return requirement
|
||||
|
||||
def summarize(self, pkgs: List[ArchPackage], root_password: Optional[str], arch_config: dict) \
|
||||
-> Optional[UpgradeRequirements]:
|
||||
|
||||
res = UpgradeRequirements([], [], [], [])
|
||||
remote_provided_map = pacman.map_provided(remote=True)
|
||||
remote_repo_map = pacman.map_repositories()
|
||||
context = UpdateRequirementsContext(to_update={}, repo_to_update={}, aur_to_update={}, repo_to_install={},
|
||||
aur_to_install={}, to_install={}, pkgs_data={}, cannot_upgrade={},
|
||||
to_remove={}, installed=dict(), provided_map={}, aur_index=set(),
|
||||
arch_config=arch_config, root_password=root_password,
|
||||
remote_provided_map=remote_provided_map, remote_repo_map=remote_repo_map,
|
||||
aur_supported=self.aur_supported)
|
||||
self.__fill_aur_index(context)
|
||||
|
||||
aur_data = {}
|
||||
aur_srcinfo_threads = []
|
||||
for p in pkgs:
|
||||
context.to_update[p.name] = p
|
||||
if p.repository == 'aur':
|
||||
context.aur_to_update[p.name] = p
|
||||
t = Thread(target=self._fill_aur_pkg_update_data, args=(p, aur_data), daemon=True)
|
||||
t.start()
|
||||
aur_srcinfo_threads.append(t)
|
||||
else:
|
||||
context.repo_to_update[p.name] = p
|
||||
|
||||
if context.aur_to_update:
|
||||
for t in aur_srcinfo_threads:
|
||||
t.join()
|
||||
|
||||
self.logger.info("Filling updates data")
|
||||
|
||||
if context.repo_to_update:
|
||||
context.pkgs_data.update(pacman.map_updates_data(context.repo_to_update.keys()))
|
||||
|
||||
if aur_data:
|
||||
context.pkgs_data.update(aur_data)
|
||||
|
||||
self.__fill_provided_map(context=context, pkgs=context.to_update)
|
||||
|
||||
if context.pkgs_data:
|
||||
self._fill_conflicts(context)
|
||||
|
||||
try:
|
||||
if not self._fill_to_install(context):
|
||||
self.logger.info("The operation was cancelled by the user")
|
||||
return
|
||||
except PackageNotFoundException as e:
|
||||
self.logger.error(f"Package '{e.name}' not found")
|
||||
return
|
||||
|
||||
if context.pkgs_data:
|
||||
self._fill_dependency_breakage(context)
|
||||
|
||||
if context.to_remove:
|
||||
self.__update_context_based_on_to_remove(context)
|
||||
|
||||
if context.to_update:
|
||||
installed_sizes = pacman.get_installed_size(list(context.to_update.keys()))
|
||||
|
||||
sorted_pkgs = []
|
||||
|
||||
if context.repo_to_update:
|
||||
# only sorting by name (pacman already knows the best order to perform the upgrade)
|
||||
sorted_pkgs.extend(context.repo_to_update.values())
|
||||
sorted_pkgs.sort(key=lambda pkg: pkg.name)
|
||||
|
||||
if context.aur_to_update: # adding AUR packages in the end
|
||||
sorted_aur = sorting.sort(context.aur_to_update.keys(), context.pkgs_data, context.provided_map)
|
||||
|
||||
for aur_pkg in sorted_aur:
|
||||
sorted_pkgs.append(context.aur_to_update[aur_pkg[0]])
|
||||
|
||||
res.to_upgrade = [self._map_requirement(pkg, context, installed_sizes) for pkg in sorted_pkgs]
|
||||
|
||||
if context.to_remove:
|
||||
res.to_remove = [p for p in context.to_remove.values()]
|
||||
|
||||
if context.cannot_upgrade:
|
||||
res.cannot_upgrade = [d for d in context.cannot_upgrade.values()]
|
||||
|
||||
if context.to_install:
|
||||
to_sync = {r.pkg.name for r in res.to_upgrade} if res.to_upgrade else {}
|
||||
to_sync.update(context.to_install.keys())
|
||||
res.to_install = [self._map_requirement(p, context, to_install=True, to_sync=to_sync)
|
||||
for p in context.to_install.values()]
|
||||
|
||||
res.context['data'] = context.pkgs_data
|
||||
return res
|
||||
|
||||
def __update_context_based_on_to_remove(self, context: UpdateRequirementsContext):
|
||||
# filtering all package to synchronization from the transaction context
|
||||
to_sync = set()
|
||||
|
||||
if context.to_update:
|
||||
to_sync.update(context.to_update.keys())
|
||||
|
||||
if context.to_install:
|
||||
to_sync.update(context.to_install.keys())
|
||||
|
||||
to_remove_provided = {}
|
||||
if to_sync: # checking if any packages to sync on the context rely on the 'to remove' ones
|
||||
to_remove_provided.update(pacman.map_provided(remote=False, pkgs=context.to_remove.keys()))
|
||||
to_remove_from_sync = {} # will store all packages that should be removed
|
||||
|
||||
for pname in to_sync:
|
||||
if pname in context.pkgs_data:
|
||||
deps = context.pkgs_data[pname].get('d')
|
||||
|
||||
if deps:
|
||||
required = set()
|
||||
|
||||
for pkg in context.to_remove:
|
||||
for provided in to_remove_provided[pkg]:
|
||||
if provided in deps:
|
||||
required.add(pkg)
|
||||
break
|
||||
|
||||
if required:
|
||||
to_remove_from_sync[pname] = required
|
||||
else:
|
||||
self.logger.warning(f"Conflict resolution: package '{pname}' marked to synchronization "
|
||||
f"has no data loaded")
|
||||
|
||||
if to_remove_from_sync: # removing all these packages and their dependents from the context
|
||||
self._add_to_remove(to_sync, to_remove_from_sync, context)
|
||||
|
||||
# checking if the installed packages that are not in the transaction context rely on the current
|
||||
# packages to be removed:
|
||||
current_to_remove = {*context.to_remove.keys()}
|
||||
required_by_to_remove = self.deps_analyser.map_all_required_by(current_to_remove, {*to_sync})
|
||||
|
||||
if required_by_to_remove:
|
||||
# updating provided context:
|
||||
provided_not_mapped = set()
|
||||
for pkg in current_to_remove.difference({*to_remove_provided.keys()}):
|
||||
if pkg not in context.pkgs_data:
|
||||
provided_not_mapped.add(pkg)
|
||||
else:
|
||||
provided = context.pkgs_data[pkg].get('p')
|
||||
if provided:
|
||||
to_remove_provided[pkg] = provided
|
||||
else:
|
||||
provided_not_mapped.add(pkg)
|
||||
|
||||
if provided_not_mapped:
|
||||
to_remove_provided.update(pacman.map_provided(remote=False, pkgs=provided_not_mapped))
|
||||
|
||||
deps_no_data = {dep for dep in required_by_to_remove if dep not in context.pkgs_data}
|
||||
deps_nodata_deps = pacman.map_required_dependencies(*deps_no_data) if deps_no_data else {}
|
||||
|
||||
reverse_to_remove_provided = {p: name for name, provided in to_remove_provided.items() for p in provided}
|
||||
|
||||
for pkg in required_by_to_remove:
|
||||
if pkg not in context.to_remove:
|
||||
if pkg in context.pkgs_data:
|
||||
dep_deps = context.pkgs_data[pkg].get('d')
|
||||
else:
|
||||
dep_deps = deps_nodata_deps.get(pkg)
|
||||
|
||||
if dep_deps:
|
||||
source = ', '.join(
|
||||
(reverse_to_remove_provided[d] for d in dep_deps if d in reverse_to_remove_provided))
|
||||
reason = f"{self.i18n['arch.info.depends on'].capitalize()} '{source if source else '?'}'"
|
||||
else:
|
||||
reason = '?'
|
||||
|
||||
pkg_repo = context.remote_repo_map.get(pkg)
|
||||
pkg_version = context.installed.get(pkg)
|
||||
context.to_remove[pkg] = UpgradeRequirement(pkg=ArchPackage(name=pkg,
|
||||
installed=True,
|
||||
i18n=self.i18n,
|
||||
version=pkg_version,
|
||||
latest_version=pkg_version,
|
||||
repository=pkg_repo),
|
||||
reason=reason)
|
||||
|
||||
for name in context.to_remove: # upgrading lists
|
||||
if name in context.pkgs_data:
|
||||
del context.pkgs_data[name]
|
||||
|
||||
if name in context.aur_to_update:
|
||||
del context.aur_to_update[name]
|
||||
|
||||
if name in context.repo_to_update:
|
||||
del context.repo_to_update[name]
|
||||
|
||||
removed_size = pacman.get_installed_size([*context.to_remove.keys()])
|
||||
|
||||
if removed_size:
|
||||
for name, size in removed_size.items():
|
||||
if size is not None:
|
||||
req = context.to_remove.get(name)
|
||||
if req:
|
||||
req.extra_size = size
|
||||
|
||||
def _add_to_remove(self, pkgs_to_sync: Set[str], names: Dict[str, Set[str]], context: UpdateRequirementsContext,
|
||||
to_ignore: Set[str] = None):
|
||||
|
||||
blacklist = to_ignore if to_ignore else set()
|
||||
blacklist.update(names)
|
||||
|
||||
dependents = {}
|
||||
for pname in pkgs_to_sync:
|
||||
if pname not in blacklist:
|
||||
data = context.pkgs_data.get(pname)
|
||||
|
||||
if data:
|
||||
deps = data.get('d')
|
||||
|
||||
if deps:
|
||||
for n in names:
|
||||
if n in deps:
|
||||
all_deps = dependents.get(n, set())
|
||||
all_deps.update(pname)
|
||||
dependents[n] = all_deps
|
||||
|
||||
else:
|
||||
self.logger.warning(f"Package '{pname}' to sync could not be removed from the transaction context "
|
||||
f"because its data was not loaded")
|
||||
|
||||
for n in names:
|
||||
if n in context.pkgs_data:
|
||||
if n not in context.to_remove:
|
||||
depends_on = names.get(n)
|
||||
if depends_on:
|
||||
reason = f"{self.i18n['arch.info.depends on'].capitalize()} '{', '.join(depends_on)}'"
|
||||
else:
|
||||
reason = '?'
|
||||
|
||||
context.to_remove[n] = UpgradeRequirement(pkg=ArchPackage(name=n, installed=True, i18n=self.i18n),
|
||||
reason=reason)
|
||||
|
||||
all_deps = dependents.get(n)
|
||||
|
||||
if all_deps:
|
||||
self._add_to_remove(pkgs_to_sync, {dep: {n} for dep in all_deps}, context, blacklist)
|
||||
else:
|
||||
self.logger.warning(f"Package '{n}' could not be removed from the transaction context because its "
|
||||
f"data was not loaded")
|
||||
|
||||
def _fill_dependency_breakage(self, context: UpdateRequirementsContext):
|
||||
if bool(context.arch_config['check_dependency_breakage']) and (context.to_update or context.to_install):
|
||||
ti = time.time()
|
||||
self.logger.info("Begin: checking dependency breakage")
|
||||
|
||||
required_by = pacman.map_required_by(context.to_update.keys()) if context.to_update else {}
|
||||
|
||||
if context.to_install:
|
||||
required_by.update(pacman.map_required_by(context.to_install.keys(), remote=True))
|
||||
|
||||
reqs_not_in_transaction = set()
|
||||
reqs_in_transaction = set()
|
||||
|
||||
transaction_pkgs = {*context.to_update.keys(), *context.to_install.keys()}
|
||||
|
||||
for reqs in required_by.values():
|
||||
for r in reqs:
|
||||
if r in transaction_pkgs:
|
||||
reqs_in_transaction.add(r)
|
||||
elif r in context.installed:
|
||||
reqs_not_in_transaction.add(r)
|
||||
|
||||
if not reqs_not_in_transaction and not reqs_in_transaction:
|
||||
return
|
||||
|
||||
provided_versions = {}
|
||||
|
||||
for p in context.provided_map:
|
||||
pkg_split = p.split('=')
|
||||
|
||||
if len(pkg_split) > 1:
|
||||
versions = provided_versions.get(pkg_split[0])
|
||||
|
||||
if versions is None:
|
||||
versions = set()
|
||||
provided_versions[pkg_split[0]] = versions
|
||||
|
||||
versions.add(pkg_split[1])
|
||||
|
||||
if not provided_versions:
|
||||
return
|
||||
|
||||
cannot_upgrade = set()
|
||||
|
||||
for pkg, deps in pacman.map_required_dependencies(*reqs_not_in_transaction).items():
|
||||
self._add_dependency_breakage(pkgname=pkg,
|
||||
pkgdeps=deps,
|
||||
provided_versions=provided_versions,
|
||||
cannot_upgrade=cannot_upgrade,
|
||||
context=context)
|
||||
|
||||
for pkg in reqs_in_transaction:
|
||||
data = context.pkgs_data[pkg]
|
||||
|
||||
if data and data['d']:
|
||||
self._add_dependency_breakage(pkgname=pkg,
|
||||
pkgdeps=data['d'],
|
||||
provided_versions=provided_versions,
|
||||
cannot_upgrade=cannot_upgrade,
|
||||
context=context)
|
||||
|
||||
if cannot_upgrade:
|
||||
pkgs_available = {*context.to_update.values(), *context.to_install.values()}
|
||||
cannot_upgrade.update(self._add_dependents_as_cannot_upgrade(context=context,
|
||||
names=cannot_upgrade,
|
||||
pkgs_available=pkgs_available))
|
||||
|
||||
for p in cannot_upgrade:
|
||||
if p in context.to_update:
|
||||
del context.to_update[p]
|
||||
|
||||
if p in context.repo_to_update:
|
||||
del context.repo_to_update[p]
|
||||
|
||||
if p in context.aur_to_update:
|
||||
del context.aur_to_update[p]
|
||||
|
||||
if p in context.pkgs_data:
|
||||
del context.pkgs_data[p]
|
||||
|
||||
if p in context.to_install:
|
||||
del context.to_install[p]
|
||||
|
||||
if p in context.repo_to_install:
|
||||
del context.repo_to_install[p]
|
||||
|
||||
if p in context.aur_to_install:
|
||||
del context.aur_to_install[p]
|
||||
|
||||
tf = time.time()
|
||||
self.logger.info("End: checking dependency breakage. Time: {0:.2f} seconds".format(tf - ti))
|
||||
|
||||
def _add_dependents_as_cannot_upgrade(self, context: UpdateRequirementsContext, names: Iterable[str],
|
||||
pkgs_available: Set[ArchPackage], already_removed: Optional[Set[str]] = None,
|
||||
iteration_level: int = 0) -> Set[str]:
|
||||
removed = set() if already_removed is None else already_removed
|
||||
removed.update(names)
|
||||
|
||||
available = {p for p in pkgs_available if p.name not in removed}
|
||||
to_remove = set()
|
||||
|
||||
if available:
|
||||
for pkg in available:
|
||||
if pkg.name not in removed:
|
||||
data = context.pkgs_data.get(pkg.name)
|
||||
|
||||
if data and data['d']:
|
||||
for dep in data['d']:
|
||||
dep_providers = context.provided_map.get(dep)
|
||||
|
||||
if dep_providers:
|
||||
for p in dep_providers:
|
||||
if p in names:
|
||||
to_remove.add(pkg.name)
|
||||
|
||||
if pkg.name not in context.cannot_upgrade:
|
||||
reason = f"{self.i18n['arch.info.depends on'].capitalize()} {p}"
|
||||
req = UpgradeRequirement(pkg=pkg, reason=reason,
|
||||
sorting_priority=iteration_level - 1)
|
||||
context.cannot_upgrade[pkg.name] = req
|
||||
break
|
||||
|
||||
if to_remove:
|
||||
removed.update(to_remove)
|
||||
self._add_dependents_as_cannot_upgrade(context=context, names=to_remove, pkgs_available=available,
|
||||
already_removed=to_remove, iteration_level=iteration_level-1)
|
||||
|
||||
return to_remove
|
||||
|
||||
def _add_dependency_breakage(self, pkgname: str, pkgdeps: Optional[Set[str]],
|
||||
provided_versions: Dict[str, Set[str]], cannot_upgrade: Set[str],
|
||||
context: UpdateRequirementsContext):
|
||||
if pkgdeps:
|
||||
for dep in pkgdeps:
|
||||
dep_split = RE_DEP_OPERATORS.split(dep)
|
||||
|
||||
if len(dep_split) > 1 and dep_split[1]:
|
||||
real_providers = context.provided_map.get(dep_split[0])
|
||||
|
||||
if real_providers:
|
||||
versions = provided_versions.get(dep_split[0])
|
||||
|
||||
if versions:
|
||||
op = ''.join(RE_DEP_OPERATORS.findall(dep))
|
||||
|
||||
version_match = False
|
||||
|
||||
for v in versions:
|
||||
try:
|
||||
if match_required_version(current_version=v,
|
||||
operator=op,
|
||||
required_version=dep_split[1]):
|
||||
version_match = True
|
||||
break
|
||||
except:
|
||||
self.logger.error(f"Error when comparing versions {v} (provided) and "
|
||||
f"{dep_split[1]} (required)")
|
||||
traceback.print_exc()
|
||||
|
||||
if not version_match:
|
||||
for pname in real_providers:
|
||||
if pname not in cannot_upgrade:
|
||||
provider = context.to_update.get(pname)
|
||||
if provider:
|
||||
cannot_upgrade.add(pname)
|
||||
reason = self.i18n['arch.sync.dep_breakage.reason'].format(pkgname, dep)
|
||||
context.cannot_upgrade[pname] = UpgradeRequirement(pkg=provider,
|
||||
reason=reason)
|
||||
@@ -1,595 +0,0 @@
|
||||
from __future__ import annotations
|
||||
import glob
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import time
|
||||
import traceback
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
from threading import Thread
|
||||
from typing import Optional
|
||||
|
||||
import requests
|
||||
|
||||
from bauh import __app_name__
|
||||
from bauh.api.abstract.context import ApplicationContext
|
||||
from bauh.api.abstract.handler import TaskManager
|
||||
from bauh.commons.boot import CreateConfigFile
|
||||
from bauh.commons.html import bold
|
||||
from bauh.commons.system import new_root_subprocess, ProcessHandler
|
||||
from bauh.gems.arch import pacman, disk, CUSTOM_MAKEPKG_FILE, ARCH_CONFIG_DIR, AUR_INDEX_FILE, get_icon_path, database, \
|
||||
mirrors, ARCH_CACHE_DIR, AUR_INDEX_TS_FILE, aur
|
||||
from bauh.gems.arch.aur import URL_INDEX
|
||||
from bauh.view.util.translation import I18n
|
||||
|
||||
from typing import TYPE_CHECKING
|
||||
if TYPE_CHECKING:
|
||||
from bauh.gems.arch.controller import ArchManager
|
||||
|
||||
URL_INFO = 'https://aur.archlinux.org/rpc/?v=5&type=info&arg={}'
|
||||
|
||||
GLOBAL_MAKEPKG = '/etc/makepkg.conf'
|
||||
|
||||
RE_MAKE_FLAGS = re.compile(r'#?\s*MAKEFLAGS\s*=\s*.+\s*')
|
||||
RE_CLEAR_REPLACE = re.compile(r'[\-_.]')
|
||||
|
||||
|
||||
class AURIndexUpdater(Thread):
|
||||
|
||||
def __init__(self, context: ApplicationContext, taskman: TaskManager, create_config: Optional[CreateConfigFile] = None, arch_config: Optional[dict] = None):
|
||||
super(AURIndexUpdater, self).__init__(daemon=True)
|
||||
self.http_client = context.http_client
|
||||
self.i18n = context.i18n
|
||||
self.logger = context.logger
|
||||
self.taskman = taskman
|
||||
self.task_id = 'index_aur'
|
||||
self.create_config = create_config
|
||||
self.config = arch_config
|
||||
self.taskman.register_task(self.task_id, self.i18n['arch.task.aur.index.status'], get_icon_path())
|
||||
|
||||
def should_update(self) -> bool:
|
||||
if not aur.is_supported(self.config):
|
||||
return False
|
||||
|
||||
try:
|
||||
exp_hours = int(self.config['aur_idx_exp'])
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
return True
|
||||
|
||||
if exp_hours <= 0:
|
||||
return True
|
||||
|
||||
if not os.path.exists(AUR_INDEX_FILE):
|
||||
return True
|
||||
|
||||
if not os.path.exists(AUR_INDEX_TS_FILE):
|
||||
return True
|
||||
|
||||
with open(AUR_INDEX_TS_FILE) as f:
|
||||
timestamp_str = f.read()
|
||||
|
||||
try:
|
||||
index_timestamp = datetime.fromtimestamp(float(timestamp_str), tz=timezone.utc)
|
||||
return (index_timestamp + timedelta(hours=exp_hours)) <= datetime.now(timezone.utc)
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
return True
|
||||
|
||||
def update_index(self):
|
||||
self.logger.info('Indexing AUR packages')
|
||||
self.taskman.update_progress(self.task_id, 5, self.i18n['arch.task.aur.index.substatus.download'])
|
||||
try:
|
||||
index_ts = datetime.now(timezone.utc).timestamp()
|
||||
res = self.http_client.get(URL_INDEX)
|
||||
|
||||
if res and res.text:
|
||||
index_progress = 50
|
||||
self.taskman.update_progress(self.task_id, index_progress,
|
||||
self.i18n['arch.task.aur.index.substatus.gen_index'])
|
||||
indexed = 0
|
||||
|
||||
Path(os.path.dirname(AUR_INDEX_FILE)).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
with open(AUR_INDEX_FILE, 'w+') as f:
|
||||
lines = res.text.split('\n')
|
||||
progress_inc = round(len(lines) / 50) # 1%
|
||||
|
||||
perc_count = 0
|
||||
for n in lines:
|
||||
if index_progress < 100 and perc_count == progress_inc:
|
||||
index_progress += 1
|
||||
perc_count = 0
|
||||
self.taskman.update_progress(self.task_id, index_progress,
|
||||
self.i18n['arch.task.aur.index.substatus.gen_index'])
|
||||
|
||||
if n and not n.startswith('#'):
|
||||
f.write('{}={}\n'.format(RE_CLEAR_REPLACE.sub('', n), n))
|
||||
indexed += 1
|
||||
|
||||
perc_count += 1
|
||||
|
||||
with open(AUR_INDEX_TS_FILE, 'w+') as f:
|
||||
f.write(str(index_ts))
|
||||
|
||||
self.logger.info('Pre-indexed {} AUR package names at {}'.format(indexed, AUR_INDEX_FILE))
|
||||
self.taskman.update_progress(self.task_id, 100, None)
|
||||
|
||||
else:
|
||||
self.logger.warning('No data returned from: {}'.format(URL_INDEX))
|
||||
self.taskman.update_progress(self.task_id, 100, self.i18n['arch.task.aur.index.substatus.error.no_data'])
|
||||
|
||||
except requests.exceptions.ConnectionError:
|
||||
self.logger.warning('No internet connection: could not pre-index packages')
|
||||
self.taskman.update_progress(self.task_id, 100, self.i18n['arch.task.aur.index.substatus.error.download'])
|
||||
|
||||
def run(self):
|
||||
ti = time.time()
|
||||
|
||||
if self.create_config:
|
||||
self.taskman.update_progress(self.task_id, 0, self.i18n['task.waiting_task'].format(self.create_config.task_name))
|
||||
self.create_config.join()
|
||||
self.config = self.create_config.config
|
||||
|
||||
self.taskman.update_progress(self.task_id, 1, self.i18n['arch.task.aur.index.substatus.checking'])
|
||||
|
||||
if self.should_update():
|
||||
self.update_index()
|
||||
else:
|
||||
self.logger.info("AUR index is up to date. Aborting...")
|
||||
self.taskman.update_progress(self.task_id, 100, None)
|
||||
|
||||
tf = time.time()
|
||||
self.taskman.finish_task(self.task_id)
|
||||
self.logger.info("Finished. Took {0:.5f} seconds".format(tf - ti))
|
||||
|
||||
|
||||
class ArchDiskCacheUpdater(Thread):
|
||||
|
||||
def __init__(self, taskman: TaskManager, i18n: I18n, logger: logging.Logger,
|
||||
controller: ArchManager, internet_available: bool, aur_indexer: Thread,
|
||||
create_config: CreateConfigFile):
|
||||
super(ArchDiskCacheUpdater, self).__init__(daemon=True)
|
||||
self.logger = logger
|
||||
self.taskman = taskman
|
||||
self.task_id = 'arch_cache_up'
|
||||
self.i18n = i18n
|
||||
self.indexed = 0
|
||||
self.indexed_template = self.i18n['arch.task.disk_cache.indexed'] + ': {}/ {}'
|
||||
self.to_index = 0
|
||||
self.progress = 0 # progress is defined by the number of packages prepared and indexed
|
||||
self.controller = controller
|
||||
self.internet_available = internet_available
|
||||
self.installed_hash_path = f'{ARCH_CACHE_DIR}/installed.sha1'
|
||||
self.installed_cache_dir = f'{ARCH_CACHE_DIR}/installed'
|
||||
self.aur_indexer = aur_indexer
|
||||
self.create_config = create_config
|
||||
self.taskman.register_task(self.task_id, self.i18n['arch.task.disk_cache'], get_icon_path())
|
||||
|
||||
def update_indexed(self, pkgname: str):
|
||||
self.indexed += 1
|
||||
sub = self.indexed_template.format(self.indexed, self.to_index)
|
||||
progress = self.progress + (self.indexed / self.to_index) * 50
|
||||
self.taskman.update_progress(self.task_id, progress, sub)
|
||||
|
||||
def _update_progress(self, progress: float, msg: str):
|
||||
self.progress = progress
|
||||
self.taskman.update_progress(self.task_id, self.progress, msg)
|
||||
|
||||
def _notify_reading_files(self):
|
||||
self._update_progress(50, self.i18n['arch.task.disk_cache.indexing'])
|
||||
|
||||
def run(self):
|
||||
ti = time.time()
|
||||
self.taskman.update_progress(self.task_id, 0, self.i18n['task.waiting_task'].format(self.create_config.task_name))
|
||||
self.create_config.join()
|
||||
|
||||
config = self.create_config.config
|
||||
aur_supported, repositories = aur.is_supported(config), config['repositories']
|
||||
|
||||
self.taskman.update_progress(self.task_id, 1, None)
|
||||
if not any([aur_supported, repositories]):
|
||||
self.taskman.update_progress(self.task_id, 100, self.i18n['arch.task.disabled'])
|
||||
self.taskman.finish_task(self.task_id)
|
||||
return
|
||||
|
||||
self.logger.info("Checking already cached package data")
|
||||
self._update_progress(1, self.i18n['arch.task.disk_cache.checking'])
|
||||
|
||||
cache_dirs = [fpath for fpath in glob.glob('{}/*'.format(self.installed_cache_dir)) if os.path.isdir(fpath)]
|
||||
|
||||
not_cached_names = None
|
||||
|
||||
self._update_progress(15, self.i18n['arch.task.disk_cache.checking'])
|
||||
if cache_dirs: # if there are cache data
|
||||
installed_names = pacman.list_installed_names()
|
||||
cached_pkgs = {cache_dir.split('/')[-1] for cache_dir in cache_dirs}
|
||||
|
||||
not_cached_names = installed_names.difference(cached_pkgs)
|
||||
self._update_progress(20, self.i18n['arch.task.disk_cache.checking'])
|
||||
|
||||
if not not_cached_names:
|
||||
self.taskman.update_progress(self.task_id, 100, '')
|
||||
self.taskman.finish_task(self.task_id)
|
||||
tf = time.time()
|
||||
time_msg = '{0:.2f} seconds'.format(tf - ti)
|
||||
self.logger.info('Finished: no package data to cache ({})'.format(time_msg))
|
||||
return
|
||||
|
||||
self.logger.info('Pre-caching installed Arch packages data to disk')
|
||||
|
||||
if aur_supported and self.aur_indexer:
|
||||
self.taskman.update_progress(self.task_id, 20, self.i18n['arch.task.disk_cache.waiting_aur_index'].format(bold(self.i18n['arch.task.aur.index.status'])))
|
||||
self.aur_indexer.join()
|
||||
|
||||
self._update_progress(21, self.i18n['arch.task.disk_cache.checking'])
|
||||
installed = self.controller.read_installed(disk_loader=None, internet_available=self.internet_available,
|
||||
only_apps=False, pkg_types=None, limit=-1, names=not_cached_names,
|
||||
wait_disk_cache=False).installed
|
||||
|
||||
self._update_progress(35, self.i18n['arch.task.disk_cache.checking'])
|
||||
|
||||
saved = 0
|
||||
|
||||
pkgs = {p.name: p for p in installed if ((aur_supported and p.repository == 'aur') or (repositories and p.repository != 'aur')) and not os.path.exists(p.get_disk_cache_path())}
|
||||
self.to_index = len(pkgs)
|
||||
|
||||
# overwrite == True because the verification already happened
|
||||
self._update_progress(40, self.i18n['arch.task.disk_cache.reading_files'])
|
||||
saved += disk.write_several(pkgs=pkgs,
|
||||
after_desktop_files=self._notify_reading_files,
|
||||
after_written=self.update_indexed, overwrite=True)
|
||||
self.taskman.update_progress(self.task_id, 100, None)
|
||||
self.taskman.finish_task(self.task_id)
|
||||
|
||||
tf = time.time()
|
||||
time_msg = '{0:.2f} seconds'.format(tf - ti)
|
||||
self.logger.info('Finished: pre-cached data of {} Arch packages to the disk ({})'.format(saved, time_msg))
|
||||
|
||||
|
||||
class ArchCompilationOptimizer(Thread):
|
||||
|
||||
def __init__(self, i18n: I18n, logger: logging.Logger, taskman: TaskManager, create_config: Optional[CreateConfigFile] = None):
|
||||
super(ArchCompilationOptimizer, self).__init__(daemon=True)
|
||||
self.logger = logger
|
||||
self.i18n = i18n
|
||||
self.re_compress_xz = re.compile(r'#?\s*COMPRESSXZ\s*=\s*.+')
|
||||
self.re_compress_zst = re.compile(r'#?\s*COMPRESSZST\s*=\s*.+')
|
||||
self.re_build_env = re.compile(r'\s+BUILDENV\s*=.+')
|
||||
self.re_ccache = re.compile(r'!?ccache')
|
||||
self.taskman = taskman
|
||||
self.task_id = 'arch_make_optm'
|
||||
self.create_config = create_config
|
||||
self.taskman.register_task(self.task_id, self.i18n['arch.task.optimizing'].format(bold('makepkg.conf')), get_icon_path())
|
||||
|
||||
def _is_ccache_installed(self) -> bool:
|
||||
return bool(shutil.which('ccache'))
|
||||
|
||||
def optimize(self):
|
||||
ti = time.time()
|
||||
try:
|
||||
ncpus = os.cpu_count()
|
||||
except Exception:
|
||||
self.logger.error('Could not determine the number of processors. Aborting...')
|
||||
ncpus = None
|
||||
|
||||
if os.path.exists(GLOBAL_MAKEPKG):
|
||||
self.logger.info("Verifying if it is possible to optimize Arch packages compilation")
|
||||
|
||||
with open(GLOBAL_MAKEPKG) as f:
|
||||
global_makepkg = f.read()
|
||||
|
||||
Path(ARCH_CONFIG_DIR).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
custom_makepkg, optimizations = None, []
|
||||
|
||||
if ncpus:
|
||||
makeflags = RE_MAKE_FLAGS.findall(global_makepkg)
|
||||
|
||||
if makeflags:
|
||||
not_commented = [f for f in makeflags if not f.startswith('#')]
|
||||
|
||||
if not not_commented:
|
||||
custom_makepkg = RE_MAKE_FLAGS.sub('', global_makepkg)
|
||||
optimizations.append('MAKEFLAGS="-j$(nproc)"')
|
||||
else:
|
||||
self.logger.warning("It seems '{}' compilation flags are already customized".format(GLOBAL_MAKEPKG))
|
||||
else:
|
||||
optimizations.append('MAKEFLAGS="-j$(nproc)"')
|
||||
|
||||
self.taskman.update_progress(self.task_id, 20, None)
|
||||
|
||||
compress_xz = self.re_compress_xz.findall(custom_makepkg or global_makepkg)
|
||||
|
||||
if compress_xz:
|
||||
not_eligible = [f for f in compress_xz if not f.startswith('#') and '--threads' in f]
|
||||
|
||||
if not not_eligible:
|
||||
custom_makepkg = self.re_compress_xz.sub('', custom_makepkg or global_makepkg)
|
||||
optimizations.append('COMPRESSXZ=(xz -c -z - --threads=0)')
|
||||
else:
|
||||
self.logger.warning("It seems '{}' COMPRESSXZ is already customized".format(GLOBAL_MAKEPKG))
|
||||
else:
|
||||
optimizations.append('COMPRESSXZ=(xz -c -z - --threads=0)')
|
||||
|
||||
self.taskman.update_progress(self.task_id, 40, None)
|
||||
|
||||
compress_zst = self.re_compress_zst.findall(custom_makepkg or global_makepkg)
|
||||
|
||||
if compress_zst:
|
||||
not_eligible = [f for f in compress_zst if not f.startswith('#') and '--threads' in f]
|
||||
|
||||
if not not_eligible:
|
||||
custom_makepkg = self.re_compress_zst.sub('', custom_makepkg or global_makepkg)
|
||||
optimizations.append('COMPRESSZST=(zstd -c -z -q - --threads=0)')
|
||||
else:
|
||||
self.logger.warning("It seems '{}' COMPRESSZST is already customized".format(GLOBAL_MAKEPKG))
|
||||
else:
|
||||
optimizations.append('COMPRESSZST=(zstd -c -z -q - --threads=0)')
|
||||
|
||||
self.taskman.update_progress(self.task_id, 60, None)
|
||||
|
||||
build_envs = self.re_build_env.findall(custom_makepkg or global_makepkg)
|
||||
|
||||
if build_envs:
|
||||
build_def = None
|
||||
for e in build_envs:
|
||||
env_line = e.strip()
|
||||
|
||||
ccache_defs = self.re_ccache.findall(env_line)
|
||||
ccache_installed = self._is_ccache_installed()
|
||||
|
||||
if ccache_defs:
|
||||
if ccache_installed:
|
||||
custom_makepkg = (custom_makepkg or global_makepkg).replace(e, '')
|
||||
|
||||
if not build_def:
|
||||
build_def = self.re_ccache.sub('', env_line).replace('(', '(ccache ')
|
||||
elif not build_def:
|
||||
build_def = self.re_ccache.sub('', env_line)
|
||||
|
||||
if build_def:
|
||||
optimizations.append(build_def)
|
||||
else:
|
||||
self.logger.warning("No BUILDENV declaration found")
|
||||
|
||||
if self._is_ccache_installed():
|
||||
self.logger.info('Adding a BUILDENV declaration')
|
||||
optimizations.append('BUILDENV=(ccache)')
|
||||
|
||||
self.taskman.update_progress(self.task_id, 80, None)
|
||||
|
||||
if custom_makepkg and optimizations:
|
||||
generated_by = f'# <generated by {__app_name__}>\n'
|
||||
custom_makepkg = custom_makepkg + '\n' + generated_by + '\n'.join(optimizations) + '\n'
|
||||
|
||||
with open(CUSTOM_MAKEPKG_FILE, 'w+') as f:
|
||||
f.write(custom_makepkg)
|
||||
|
||||
self.logger.info("A custom optimized 'makepkg.conf' was generated at '{}'".format(CUSTOM_MAKEPKG_FILE))
|
||||
else:
|
||||
self.logger.info("No optimizations are necessary")
|
||||
|
||||
if os.path.exists(CUSTOM_MAKEPKG_FILE):
|
||||
self.logger.info("Removing old optimized 'makepkg.conf' at '{}'".format(CUSTOM_MAKEPKG_FILE))
|
||||
os.remove(CUSTOM_MAKEPKG_FILE)
|
||||
|
||||
self.taskman.update_progress(self.task_id, 100, None)
|
||||
tf = time.time()
|
||||
self.logger.info('Finished. {0:.2f} seconds'.format(tf - ti))
|
||||
|
||||
def run(self):
|
||||
ti = time.time()
|
||||
if self.create_config:
|
||||
self.taskman.update_progress(self.task_id, 0, self.i18n['task.waiting_task'].format(bold(self.create_config.task_name)))
|
||||
self.create_config.join()
|
||||
|
||||
self.taskman.update_progress(self.task_id, 1, None)
|
||||
|
||||
if self.create_config.config['optimize'] and aur.is_supported(self.create_config.config):
|
||||
try:
|
||||
self.optimize()
|
||||
except Exception:
|
||||
self.logger.error("Unexpected exception")
|
||||
traceback.print_exc()
|
||||
self.taskman.update_progress(self.task_id, 100, None)
|
||||
else:
|
||||
self.logger.info("AUR packages compilation optimizations are disabled")
|
||||
|
||||
if os.path.exists(CUSTOM_MAKEPKG_FILE):
|
||||
try:
|
||||
self.logger.info("Removing custom 'makepkg.conf' -> '{}'".format(CUSTOM_MAKEPKG_FILE))
|
||||
os.remove(CUSTOM_MAKEPKG_FILE)
|
||||
except Exception:
|
||||
self.logger.error("Unexpected exception")
|
||||
traceback.print_exc()
|
||||
|
||||
self.taskman.update_progress(self.task_id, 100, self.i18n['arch.task.disabled'])
|
||||
|
||||
tf = time.time()
|
||||
self.taskman.finish_task(self.task_id)
|
||||
self.logger.info('Finished. Took {0:.2f} seconds'.format(tf - ti))
|
||||
|
||||
|
||||
class RefreshMirrors(Thread):
|
||||
|
||||
def __init__(self, taskman: TaskManager, root_password: Optional[str], i18n: I18n, logger: logging.Logger,
|
||||
create_config: CreateConfigFile):
|
||||
super(RefreshMirrors, self).__init__(daemon=True)
|
||||
self.taskman = taskman
|
||||
self.i18n = i18n
|
||||
self.logger = logger
|
||||
self.root_password = root_password
|
||||
self.task_id = "arch_mirrors"
|
||||
self.create_config = create_config
|
||||
self.refreshed = False
|
||||
self.task_name = self.i18n['arch.task.mirrors']
|
||||
self.taskman.register_task(self.task_id, self.task_name, get_icon_path())
|
||||
|
||||
def _notify_output(self, output: str):
|
||||
self.taskman.update_output(self.task_id, output)
|
||||
|
||||
@staticmethod
|
||||
def is_enabled(arch_config: dict, aur_supported: bool) -> bool:
|
||||
return (arch_config['repositories'] or aur_supported) \
|
||||
and arch_config['refresh_mirrors_startup'] and pacman.is_mirrors_available()
|
||||
|
||||
@classmethod
|
||||
def should_synchronize(cls, arch_config: dict, aur_supported: bool, logger: logging.Logger) -> bool:
|
||||
return cls.is_enabled(arch_config, aur_supported) and mirrors.should_sync(logger)
|
||||
|
||||
def run(self):
|
||||
ti = time.time()
|
||||
self.taskman.update_progress(self.task_id, 0, self.i18n['task.waiting_task'].format(bold(self.create_config.task_name)))
|
||||
self.create_config.join()
|
||||
|
||||
arch_config = self.create_config.config
|
||||
aur_supported = aur.is_supported(arch_config)
|
||||
|
||||
self.taskman.update_progress(self.task_id, 1, self.i18n['arch.task.checking_settings'])
|
||||
|
||||
if not self.is_enabled(arch_config, aur_supported):
|
||||
self.taskman.update_progress(self.task_id, 100, self.i18n['arch.task.disabled'])
|
||||
self.taskman.finish_task(self.task_id)
|
||||
return
|
||||
|
||||
if not mirrors.should_sync(self.logger):
|
||||
self.taskman.update_progress(self.task_id, 100, self.i18n['arch.task.mirrors.cached'])
|
||||
self.taskman.finish_task(self.task_id)
|
||||
return
|
||||
|
||||
sort_limit = arch_config['mirrors_sort_limit']
|
||||
self.logger.info("Refreshing mirrors")
|
||||
|
||||
handler = ProcessHandler()
|
||||
try:
|
||||
self.taskman.update_progress(self.task_id, 10, '')
|
||||
success, output = handler.handle_simple(pacman.refresh_mirrors(self.root_password), output_handler=self._notify_output)
|
||||
|
||||
if success:
|
||||
|
||||
if sort_limit is not None and sort_limit >= 0:
|
||||
self.taskman.update_progress(self.task_id, 50, self.i18n['arch.custom_action.refresh_mirrors.status.updating'])
|
||||
try:
|
||||
handler.handle_simple(pacman.sort_fastest_mirrors(self.root_password, sort_limit), output_handler=self._notify_output)
|
||||
except Exception:
|
||||
self.logger.error("Could not sort mirrors by speed")
|
||||
traceback.print_exc()
|
||||
|
||||
mirrors.register_sync(self.logger)
|
||||
self.refreshed = True
|
||||
else:
|
||||
self.logger.error("It was not possible to refresh mirrors")
|
||||
except Exception:
|
||||
self.logger.error("It was not possible to refresh mirrors")
|
||||
traceback.print_exc()
|
||||
|
||||
self.taskman.update_progress(self.task_id, 100, None)
|
||||
self.taskman.finish_task(self.task_id)
|
||||
tf = time.time()
|
||||
self.logger.info("Finished. Took {0:.2f} seconds".format(tf - ti))
|
||||
|
||||
|
||||
class SyncDatabases(Thread):
|
||||
|
||||
def __init__(self, taskman: TaskManager, root_password: Optional[str], i18n: I18n, logger: logging.Logger,
|
||||
refresh_mirrors: RefreshMirrors, create_config: CreateConfigFile):
|
||||
super(SyncDatabases, self).__init__(daemon=True)
|
||||
self.task_man = taskman
|
||||
self.i18n = i18n
|
||||
self.taskman = taskman
|
||||
self.task_id = "arch_dbsync"
|
||||
self.root_password = root_password
|
||||
self.refresh_mirrors = refresh_mirrors
|
||||
self.logger = logger
|
||||
self.create_config = create_config
|
||||
self.task_name = self.i18n['arch.sync_databases.substatus']
|
||||
self.taskman.register_task(self.task_id, self.task_name, get_icon_path())
|
||||
self.synchronized = False
|
||||
|
||||
@staticmethod
|
||||
def is_enabled(arch_config: dict, aur_supported: bool) -> bool:
|
||||
return arch_config['sync_databases_startup'] and (aur_supported or arch_config['repositories'])
|
||||
|
||||
@classmethod
|
||||
def should_sync(cls, mirrors_refreshed: bool, arch_config: dict, aur_supported: bool, logger: logging.Logger):
|
||||
return mirrors_refreshed or (cls.is_enabled(arch_config, aur_supported) and database.should_sync(arch_config, aur_supported, None, logger))
|
||||
|
||||
def run(self) -> None:
|
||||
self.taskman.update_progress(self.task_id, 0, self.i18n['task.waiting_task'].format(bold(self.create_config.task_name)))
|
||||
self.create_config.join()
|
||||
|
||||
self.taskman.update_progress(self.task_id, 0, self.i18n['task.waiting_task'].format(bold(self.refresh_mirrors.task_name)))
|
||||
self.refresh_mirrors.join()
|
||||
|
||||
self.taskman.update_progress(self.task_id, 1, self.i18n['arch.task.checking_settings'])
|
||||
|
||||
arch_config = self.create_config.config
|
||||
aur_supported = aur.is_supported(arch_config)
|
||||
if not self.is_enabled(arch_config, aur_supported):
|
||||
self.taskman.update_progress(self.task_id, 100, self.i18n['arch.task.disabled'])
|
||||
self.taskman.finish_task(self.task_id)
|
||||
return
|
||||
|
||||
shoud_sync = self.refresh_mirrors.refreshed or (database.should_sync(arch_config, aur_supported, None, self.logger))
|
||||
|
||||
if not shoud_sync:
|
||||
self.taskman.update_progress(self.task_id, 100, self.i18n['arch.sync_databases.substatus.synchronized'])
|
||||
self.taskman.finish_task(self.task_id)
|
||||
self.synchronized = True
|
||||
return
|
||||
|
||||
self.logger.info("Synchronizing databases")
|
||||
self.taskman.register_task(self.task_id, self.i18n['arch.sync_databases.substatus'], get_icon_path())
|
||||
|
||||
progress = 10
|
||||
dbs = pacman.get_databases()
|
||||
self.taskman.update_progress(self.task_id, progress, None)
|
||||
|
||||
if dbs:
|
||||
inc = 90 / len(dbs)
|
||||
try:
|
||||
p = new_root_subprocess(['pacman', '-Syy'], self.root_password)
|
||||
|
||||
dbs_read, last_db = 0, None
|
||||
|
||||
for o in p.stdout:
|
||||
line = o.decode().strip()
|
||||
|
||||
if line:
|
||||
self.task_man.update_output(self.task_id, line)
|
||||
if line.startswith('downloading'):
|
||||
db = line.split(' ')[1].strip()
|
||||
|
||||
if last_db is None or last_db != db:
|
||||
last_db = db
|
||||
dbs_read += 1
|
||||
progress = dbs_read * inc
|
||||
else:
|
||||
progress += 0.25
|
||||
|
||||
self.taskman.update_progress(self.task_id, progress, self.i18n['arch.task.sync_sb.status'].format(db))
|
||||
|
||||
for o in p.stderr:
|
||||
line = o.decode().strip()
|
||||
|
||||
if line:
|
||||
self.task_man.update_output(self.task_id, line)
|
||||
|
||||
p.wait()
|
||||
|
||||
if p.returncode == 0:
|
||||
database.register_sync(self.logger)
|
||||
self.synchronized = True
|
||||
else:
|
||||
self.logger.error("Could not synchronize database")
|
||||
|
||||
except Exception:
|
||||
self.logger.info("Error while synchronizing databases")
|
||||
traceback.print_exc()
|
||||
|
||||
self.taskman.update_progress(self.task_id, 100, None)
|
||||
self.taskman.finish_task(self.task_id)
|
||||
self.logger.info("Finished")
|
||||
Reference in New Issue
Block a user