From c30407a244adbe37a87415b2c5b23b928949cd43 Mon Sep 17 00:00:00 2001 From: Emiliano Vavassori Date: Sat, 30 Apr 2022 16:58:00 +0200 Subject: [PATCH] Refactor parziale dello script. Refactor della parte getversion. --- scripts/loaih-build => loaih/script.py | 36 ++++++++-- loaih/versions.py | 99 +++++++++++++++++--------- scripts/loaih-getversion | 40 ----------- setup.py | 6 +- 4 files changed, 104 insertions(+), 77 deletions(-) rename scripts/loaih-build => loaih/script.py (82%) delete mode 100644 scripts/loaih-getversion diff --git a/scripts/loaih-build b/loaih/script.py similarity index 82% rename from scripts/loaih-build rename to loaih/script.py index 94cda81..5e8499f 100644 --- a/scripts/loaih-build +++ b/loaih/script.py @@ -4,8 +4,39 @@ import click import yaml import loaih +import re, sys, json -@click.command() +@click.group() +def cli(): + pass + +@cli.command() +@click.option('-j', '--json', 'jsonout', default=False, is_flag=True, help="Output format in json.") +@click.argument('query') +def getversion(query, jsonout): + b = [] + queries = [] + if ',' in query: + queries.extend(query.split(',')) + else: + queries.append(query) + + for q in queries: + if '.' in q: + # Numbered version. It is safe to send it to Build. + b.append(loaih.versions.Build(q)) + else: + # Named version. For safety, we call a helper method for a collection + b.extend(loaih.versions.Base.collectedbuilds(q)) + + if len(b) > 0: + if jsonout: + click.echo(json.dumps([x.todict() for x in b])) + else: + for v in b: + click.echo(v) + +@cli.command() @click.option('-a', '--arch', 'arch', type=click.Choice(['x86', 'x86_64', 'all'], case_sensitive=False), default='all', help="Build the AppImage for a specific architecture. If there is no specific options, the process will build for both architectures (if available). Default: all") @click.option('-c/-C', '--check/--no-check', 'check', default=True, help="Check in the final storage if the queried version is existent. Default: check") @click.option('-d', '--download-path', 'download_path', default = '/var/tmp/downloads', type=str, help="Path to the download folder. Default: /var/tmp/downloads") @@ -86,6 +117,3 @@ def build(arch, language, offline, portable, updatable, download_path, repo_path obj.publish() obj.generalize_and_link() del obj - -if __name__ == '__main__': - build() diff --git a/loaih/versions.py b/loaih/versions.py index ade3fbc..3192438 100644 --- a/loaih/versions.py +++ b/loaih/versions.py @@ -36,21 +36,6 @@ class Base(object): # Class for static methods which might be useful even outside the build # scripts. - @staticmethod - def dailyver(date = datetime.datetime.today()): - """Returns versions present on the latest daily build.""" - url = Base.dailyurl(date)['x86_64'] - # Since it is possible that a daily build is not yet provided... - if url == '-': - return [] - - # Rerun the page parsing, this time to find out the versions built - - b = etree.HTML(urllib.request.urlopen(Base.dailyurl(date)['x86_64']).read()).xpath("//td/a[contains(text(), '_deb.tar.gz')]/text()") - # This should have returned the main package for a version, but can - # have returned multiple ones, so let's treat it as a list - return [ x.split('_')[1] for x in b ] - @staticmethod def dailyurl(date = datetime.datetime.today()): """Returns the URL for the latest valid daily build.""" @@ -68,6 +53,20 @@ class Base(object): # list and get the latest item return { 'x86': '-', 'x86_64': Definitions.SELECTORS['daily']['URL'] + sorted(a)[-1] } + @staticmethod + def dailyver(date = datetime.datetime.today()): + """Returns versions present on the latest daily build.""" + url = Base.dailyurl(date)['x86_64'] + # If no daily releases has been provided yet, return empty + if url == '-': + return [] + + # Rerun the page parsing, this time to find out the versions built + b = etree.HTML(urllib.request.urlopen(url).read()).xpath("//td/a[contains(text(), '_deb.tar.gz')]/text()") + # This should have returned the main package for a version, but can + # have returned multiple ones, so let's treat it as a list + return [ x.split('_')[1] for x in b ] + @staticmethod def namedver(query): """Gets the version for a specific named version.""" @@ -87,7 +86,7 @@ class Base(object): @staticmethod def fullversion(version): """Get latest full version from Archive based on partial version.""" - versionlist = etree.HTML(urllib.request.urlopen(Definitions.ARCHIVE).read()).xpath("//td/a[starts-with(text(), '" + version + "')]/text()") + versionlist = etree.HTML(urllib.request.urlopen(Definitions.ARCHIVE).read()).xpath(f"//td/a[starts-with(text(), '{version}')]/text()") cleanlist = sorted([ x.strip('/') for x in versionlist ]) # Sorting, then returning the last version @@ -112,7 +111,7 @@ class Base(object): # If the version has only 2 points in it (or splits into three parts by '.'), that's not a full version and we will call the getlatestver() function fullversion = version - if len(version.split('.')) == 3: + if len(version.split('.')) <= 3: fullversion = Base.fullversion(version) # So the final URL is the Archive one, plus the full versions, plus a @@ -130,31 +129,67 @@ class Base(object): return retval + @staticmethod + def collectedbuilds(query): + """Creates a list of Builds based on each namedver found.""" + retval = [] + a = Base.namedver(query) + if isinstance(a, list) and len(a) > 1: + retval = [ Build(query, version) for version in Base.namedver(query) ] + else: + retval.append(Build(query)) + + return retval + class Build(object): - def __init__(self, query): + def __init__(self, query, version = None): """Should simplify the single builded version.""" self.query = query self.version = '' - self.basedirurl = {} + self.basedirurl = { 'x86': '-', 'x86_64': '-' } - # For simplification process, let's before see if there's a named query - # (it shouldn't) if not '.' in self.query: - # Named version. Let's get the result of the query. - a = Base.namedver(self.query) + # Named version. + # Let's check if a specific version was requested. + if version: + self.version = version + else: + # In case it was not requested, we will carry on the generic + # namedver() query. + # If the results are more than one, we'll take the latest (since we are requested to provide a single build). + a = Base.namedver(self.query) + + if isinstance(a, list) and len(a) == 0: + # No results from the query - let's return default values + return - if len(a) != 1: - raise Exception("Queried version for build does not return a single result. Please unfold manually. Exiting.") - - # So if it is here, the version is one. - self.query = a[0] - - if len(self.query.split('.')) == 4: - self.version = self.query + if len(a) == 1: + # version is a single one. + self.version = a[0] + else: + # In this case, we will select the latest release. + self.version = sorted(a)[-1] else: + # In case of numbered queries, put it as initial version + self.version = self.query + + if len(self.version.split('.')) < 4: # If not 4 dotted, let's search for the 4 dotted version - self.version = Base.fullversion(self.query) + self.version = Base.fullversion(self.version) self.basedirurl = Base.urlfromqueryandver(self.query, self.version) + + def todict(self): + return { + 'query': self.query, + 'version': self.version, + 'basedirurl': self.basedirurl + } + + def __str__(self): + return f"""query: {self.query} +version: {self.version} +x86: {self.basedirurl['x86']} +x86_64: {self.basedirurl['x86_64']}""" diff --git a/scripts/loaih-getversion b/scripts/loaih-getversion deleted file mode 100644 index e9d2c04..0000000 --- a/scripts/loaih-getversion +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env python -# encoding: utf-8 - -import click -import loaih.versions as versions -import re, sys, json - -@click.command() -@click.option('-o', '--output', default = 'rundeck', type=click.Choice(['rundeck', 'json', 'text' ], case_sensitive=False), help="Output format, defaulting to Rundeck Key/Value data format. Options: rundeck,json,text") -@click.argument('query') -def getversion(query, output): - b = [] - if '.' in query: - b.append(versions.Build(query)) - else: - # In case of names, we might want to loop for versions. So we before - # get the versions available, based on query. - vers = versions.Base.namedver(query) - if len(vers) != 1: - for v in vers: - b.append(versions.Build(v)) - else: - b = versions.Build(vers[0]) - - if output.lower() == 'json': - output = { - 'query': query, - 'version': b.version, - 'basedirurl': b.basedirurl - } - print(json.dumps(output)) - else: - print("""query: {query} -version: {version} -x86: {x86_url} -x86_64: {x86_64_url}""".format(query = query, version = b.version, x86_url = b.basedirurl['x86'], x86_64_url = b.basedirurl['x86_64'])) - - -if __name__ == '__main__': - getversion() diff --git a/setup.py b/setup.py index 4ee9309..e4ad69f 100644 --- a/setup.py +++ b/setup.py @@ -11,7 +11,11 @@ setup( author="Emiliano Vavassori", author_email="syntaxerrormmm@libreoffice.org", packages=find_packages(exclude=['contrib', 'docs', 'tests']), - scripts=[ 'scripts/loaih-getversion', 'scripts/loaih-build' ], + entry_points={ + 'console_scripts': [ + 'loaih = loaih.script:cli', + ], + }, install_requires=[ 'click', ], license='MIT', url='https://git.libreitalia.org/LibreItalia/loappimage-helpers/',