.gitlab-ci.yml

@@ -16,25 +16,23 @@ cache:
   paths:
     - .cache/pip
 
-before_script:
-  - apt-get -y update
-  - command -v git || apt-get -y install git
-  - command -v python3 || apt-get -y install python3
-  - command -v pip3 || apt-get -y install python3-pip twine python3-build
-  - command -v curl || apt-get -y install curl
-  - command -v bsdtar || apt-get -y install libarchive-tools
-  - python3 -V  # Print out python version for debugging
-  - python3 -m venv || apt-get -y install python3-venv
-  - if [[ "$CI_COMMIT_BRANCH" != "main" ]]; then sed -i "s%git+https://gitlab.kit.edu/scc-net/netvs/api-generator.git@main%git+https://gitlab.kit.edu/scc-net/netvs/api-generator.git@${CI_COMMIT_BRANCH}%g" pyproject.toml; fi
-  - if [[ "$CI_COMMIT_BRANCH" == "devel" ]]; then export NETDB_ENDPOINT=${NETDB_DEVEL_ENDPOINT}; fi
-
-
 stages:
   - build
 
 build:
   stage: build
   resource_group: ${CI_COMMIT_BRANCH} # this prevents parallel (potentially racy) pipeline runs
+  before_script:
+    - apt-get -y update
+    - command -v git || apt-get -y install git
+    - command -v python3 || apt-get -y install python3
+    - command -v pip3 || apt-get -y install python3-pip twine python3-build
+    - command -v curl || apt-get -y install curl
+    - command -v bsdtar || apt-get -y install libarchive-tools
+    - python3 -V  # Print out python version for debugging
+    - python3 -m venv || apt-get -y install python3-venv
+    - if [[ "$CI_COMMIT_BRANCH" != "main" ]]; then sed -i "s%git+https://gitlab.kit.edu/scc-net/netvs/api-generator.git@main%git+https://gitlab.kit.edu/scc-net/netvs/api-generator.git@${CI_COMMIT_BRANCH}%g" pyproject.toml; fi
+    - if [[ "$CI_COMMIT_BRANCH" == "devel" ]]; then export NETDB_ENDPOINT=${NETDB_DEVEL_ENDPOINT}; fi
   script:
     - mkdir -p latest
     - "(curl -LsS \"${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/jobs/artifacts/${CI_COMMIT_BRANCH}/download?job=build&job_token=${CI_JOB_TOKEN}\" | bsdtar -xf - -C latest) || true"
@@ -42,7 +40,6 @@ build:
     - test -d latest/dist && export LATEST_API_VERSION=$(cd latest/dist; ls *.whl | sed -r 's/netdb_client-([0-9]+\.[0-9]+\.[0-9]+).*/\1/g')
     - test -d latest/dist && export POST_NUM=$(cd latest/dist; ls *.whl | sed -r 's/.*\.post([0-9]+).*/\1/g')
     - python3 -m build
-    - TWINE_PASSWORD=${CI_JOB_TOKEN} TWINE_USERNAME=gitlab-ci-token python3 -m twine upload --verbose --repository-url ${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/pypi --skip-existing dist/*
   artifacts:
     paths:
       - dist/*
@@ -50,3 +47,19 @@ build:
   only:
     - main
     - devel
+
+upload:
+  stage: build
+  resource_group: ${CI_COMMIT_BRANCH} # this prevents parallel (potentially racy) pipeline runs
+  before_script:
+    - apt-get -y update
+    - command -v git || apt-get -y install git
+    - command -v twine || apt-get -y install twine
+  script:
+    - TWINE_PASSWORD=${CI_JOB_TOKEN} TWINE_USERNAME=gitlab-ci-token twine upload --verbose --repository-url ${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/pypi --skip-existing dist/*
+  needs:
+    - job: build
+      artifacts: true
+  only:
+    - main
+    - devel

examples/argparse-example.py

+from netdb_client.api41 import APIEndpoint, APISession, dns
+
+from netdb_client.util.argparse_helper import ArgumentParser
+
+parser = ArgumentParser()
+
+args = parser.parse_args()
+
+endpoint = APIEndpoint(base_url=args.netdb_base_url, token=args.netdb_token)
+api = APISession(endpoint)
+
+fqdn = dns.Fqdn.list(api, value_old='net.scc.kit.edu')
+
+print(fqdn)

examples/click-example.py

+import click
+from netdb_client import api41
+from netdb_client.api41 import APISession, dns
+
+from netdb_client.util.click_helper import netdb_api_options
+
+
+@click.command(context_settings={'help_option_names': ['-h', '--help'], 'max_content_width': 160})
+@netdb_api_options(api41)
+def main(netdb_api_endpoint):
+    netdb_api = APISession(netdb_api_endpoint)
+
+    fqdn = dns.Fqdn.list(netdb_api, value_old='net.scc.kit.edu')
+
+    print(fqdn)
+
+
+if __name__ == '__main__':
+    main()

examples/typer-example.py

+import typer
+from pathlib import Path
+from netdb_client.api41 import APIEndpoint, APISession, dns
+
+from netdb_client.util.click_helper import netdb_config_callback, netdb_endpoint_callback
+
+app = typer.Typer()
+
+
+@app.command(context_settings={'help_option_names': ['-h', '--help'], 'max_content_width': 120})
+def main(
+    _netdb_config: Path = typer.Option(
+        Path('~/.config/netdb_client.ini'),
+        '--netdb-config',
+        help='netdb auth config file path',
+        callback=netdb_config_callback,
+        is_eager=True,
+        expose_value=False,
+    ),
+    netdb_endpoint: str = typer.Option(
+        None,
+        '--netdb-endpoint',
+        envvar='NETDB_ENDPOINT',
+        help='endpoint to use. Config: [DEFAULT]: endpoint',
+        callback=netdb_endpoint_callback,
+        expose_value=False,
+    ),
+    netdb_base_url: str = typer.Option(
+        None, '--netdb-base-url', envvar='NETDB_BASE_URL', help='webapi server. Config: [$endpoint]: base_url'
+    ),
+    netdb_token: str = typer.Option(
+        None, '--netdb-token', envvar='NETDB_TOKEN', show_default=False, help='user API token. Config: [$endpoint]: token'
+    ),
+):
+    netdb_enpoint = APIEndpoint(base_url=netdb_base_url, token=netdb_token)
+    netdb_api = APISession(netdb_enpoint)
+
+    fqdn = dns.Fqdn.list(netdb_api, value_old='net.scc.kit.edu')
+
+    print(fqdn)
+
+
+if __name__ == '__main__':
+    app()

netdb_client/util.py

-"""netdb_client helper functions for configuration and response-parsing"""
-import argparse
-import configparser
-import os
-import stat
-
-
-class ArgumentParser(argparse.ArgumentParser):
-    """Argument parser with default common arguments for NetDB-api cli
-    tools. Includes default values."""
-
-    def __init__(
-            self,
-            epilog="The Variables BASE_URL, VERSION and TOKEN can be loaded from config file,"
-                   "environment or from command line arguments.\n"
-                   "Variable precendence is as followed (from greatest to least,"
-                   "means the first listed variable overwrites all other variables):\n"
-                   "  1. cli-arguments\n"
-                   "  2. environment variables\n"
-                   "  3. config-file\n",
-            formatter_class=argparse.RawTextHelpFormatter,
-            **kwargs
-    ):
-        super().__init__(formatter_class=formatter_class, epilog=epilog, **kwargs)
-        self.add_argument('--auth-config',
-                          default=os.path.expanduser('~/.config/netdb_client.ini'),
-                          help='config file path (default: %(default)s)')
-        self.add_argument('--endpoint', '-e',
-                          help='endpoint to use.\n'
-                               'Environment: "NETDB_ENDPOINT"\n'
-                               'Config: [DEFAULT]: endpoint')
-        self.add_argument('--base-url', '-b',
-                          help='webapi server.\n'
-                               'Environment: "NETDB_BASE_URL"\n'
-                               'Config: [$endpoint]: base_url')
-        self.add_argument('--token', '-t',
-                          help='user API token.\n'
-                               'Environment: "NETDB_TOKEN"\n'
-                               'Config: [$endpoint]: token')
-
-    def parse_args(self, args=None, namespace=None):
-        args = super().parse_args(args, namespace)
-        config = configparser.ConfigParser()
-        configpath = os.path.expanduser(args.auth_config)
-        if os.path.isfile(configpath):
-            if os.stat(configpath).st_mode & stat.S_IRWXO:
-                self.error(f"Config file is readable by others. Please set it at least to 600 but never other-readable.")
-            config.read(configpath)
-
-        def load_config(option):
-            """load config for an option"""
-
-            # if value is already set, we can stop here
-            if getattr(args, option) is not None:
-                return
-
-            # try to load option from environment
-            value = os.getenv(f'NETDB_{option.upper()}', None)
-
-            if value is None:
-                # endpoint should be loaded from DEFAULT section
-                if option == 'endpoint':
-                    section = 'DEFAULT'
-                # everything else loads from the $endpoint section
-                else:
-                    section = getattr(args, 'endpoint')
-                # load value from config section
-                value = config.get(section, option, fallback=None)
-
-            # For backwards compatibility:
-            # if base_url is still unknown use endpoint instead
-            if option == 'base_url' and value is None:
-                value = section
-
-            if value is None:
-                self.error(
-                    f'No {option} specified (looked in args, environment variable '
-                    f'"NETDB_{option.upper()}", config-file in "{args.auth_config} section {section}")')
-
-            # we have a value now and can use it
-            setattr(args, option, value)
-
-        # start with endpoint to get the right config section
-        for option in ['endpoint', 'base_url', 'token']:
-            load_config(option)
-
-        return args
-
-
-def list_to_generator_map_one2one(array, key_name):
-    """Mapping function to convert list of dicts to a mapping with value as key for each dict
-    (1 to 1 Mapping). Returns a generator object."""
-    return ((item[key_name], item) for item in array)
-
-
-def list_to_generator_map_one2many(array, key_name):
-    """Mapping function to convert list of dicts to a mapping with values as key for each lists
-     (1 to n Mapping). Returns a generator object."""
-    res = {}
-    for item in array:
-        if not item[key_name] in res:
-            res[item[key_name]] = []
-        res[item[key_name]].append(item)
-    for key, value in res.items():
-        yield key, value

netdb_client/util/__init__.py

+"""netdb_client helper functions for configuration and response-parsing"""
+
+from .argparse_helper import ArgumentParser  # for backwards compatibility
+
+__all__ = ['ArgumentParser', 'list_to_generator_map_one2one', 'list_to_generator_map_one2many']
+
+
+def list_to_generator_map_one2one(array, key_name):
+    """Mapping function to convert list of dicts to a mapping with value as key for each dict
+    (1 to 1 Mapping). Returns a generator object."""
+    return ((item[key_name], item) for item in array)
+
+
+def list_to_generator_map_one2many(array, key_name):
+    """Mapping function to convert list of dicts to a mapping with values as key for each lists
+    (1 to n Mapping). Returns a generator object."""
+    res = {}
+    for item in array:
+        if item[key_name] not in res:
+            res[item[key_name]] = []
+        res[item[key_name]].append(item)
+    for key, value in res.items():
+        yield key, value

netdb_client/util/argparse_helper.py

+"""Argparse Wrapper Class for automatic config loading"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from .config import NETDBConfig, NETDBConfigError
+
+
+class DeprecateAction(argparse.Action):
+    def __init__(self, *args, **kwargs):
+        self.call_count = 0
+        if 'help' in kwargs:
+            kwargs['help'] = f'[DEPRECATED] {kwargs["help"]}'
+        super().__init__(*args, **kwargs)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        if self.call_count == 0:
+            sys.stderr.write(f'The option `{option_string}` is deprecated. Help:\n')
+            sys.stderr.write(f'{self.help}\n')
+            sys.exit(1)
+
+
+class ArgumentParser(argparse.ArgumentParser):
+    """Argument parser with default common arguments for NetDB-api cli
+    tools. Includes default values."""
+
+    def __init__(
+        self,
+        epilog='The Variables BASE_URL, VERSION and TOKEN can be loaded from config file,'
+        'environment or from command line arguments.\n'
+        'Variable precendence is as followed (from greatest to least,'
+        'means the first listed variable overwrites all other variables):\n'
+        '  1. cli-arguments\n'
+        '  2. environment variables\n'
+        '  3. config-file\n',
+        formatter_class=argparse.RawTextHelpFormatter,
+        **kwargs,
+    ):
+        super().__init__(formatter_class=formatter_class, epilog=epilog, **kwargs)
+        self.register('action', 'deprecated', DeprecateAction)
+        self.add_argument('--auth-config', action='deprecated', help='please use --netdb-config instead')
+        self.add_argument('--endpoint', '-e', action='deprecated', help='please use --netdb-enpoint instead')
+        self.add_argument('--base-url', '-b', action='deprecated', help='please use --netdb-base-url instead')
+        self.add_argument('--token', '-t', action='deprecated', help='please use --netdb-token instead')
+        self.add_argument(
+            '--netdb-config', default='~/.config/netdb_client.ini', help='config file path (default: %(default)s)'
+        )
+        self.add_argument(
+            '--netdb-endpoint', help='endpoint to use.\n' 'Environment: "NETDB_ENDPOINT"\n' 'Config: [DEFAULT]: endpoint'
+        )
+        self.add_argument(
+            '--netdb-base-url', help='webapi server.\n' 'Environment: "NETDB_BASE_URL"\n' 'Config: [$endpoint]: base_url'
+        )
+        self.add_argument('--netdb-token', help='user API token.\n' 'Environment: "NETDB_TOKEN"\n' 'Config: [$endpoint]: token')
+
+    def parse_args(self, args=None, namespace=None):
+        args = super().parse_args(args, namespace)
+        try:
+            config = NETDBConfig(Path(args.netdb_config))
+        except NETDBConfigError as err:
+            self.error(str(err))
+
+        def load_config(option_name, config_key):
+            """load config for an option"""
+
+            # if value is already set, we can stop here
+            if getattr(args, option_name) is not None:
+                return
+            envvar_name = f'{option_name.upper()}'
+            # try to load option from environment
+            value = os.getenv(envvar_name, None)
+
+            if value is None:
+                # load value from config section
+                value = getattr(config, config_key)(args.netdb_endpoint)
+
+            # For backwards compatibility:
+            # if base_url is still unknown use endpoint instead
+            if option_name == 'base_url' and value is None:
+                value = args.netdb_endpoint
+
+            if value is None:
+                self.error(
+                    f'No {option_name} specified (looked in args, environment variable '
+                    f'"{envvar_name}", config-file in "{args.netdb_config} section {args.netdb_endpoint}")'
+                )
+
+            # we have a value now and can use it
+            setattr(args, option, value)
+
+        # start with endpoint to get the right config section
+        for option, config_key in [('netdb_endpoint', 'endpoint'), ('netdb_base_url', 'base_url'), ('netdb_token', 'token')]:
+            load_config(option, config_key)
+
+        return args

netdb_client/util/click_helper.py

+"""click framework helper functions for config loading"""
+
+import types
+from pathlib import Path
+from typing import Optional
+from functools import update_wrapper
+
+import click
+
+from netdb_client.util.config import NETDBConfig
+
+
+def _get_defaults(config: NETDBConfig, endpoint: str) -> dict[str, str]:
+    base_url = config.base_url(endpoint)
+    token = config.token(endpoint)
+
+    return {'netdb_base_url': base_url, 'netdb_token': token}
+
+
+def netdb_config_callback(ctx: click.Context, _param: click.Parameter, config_path: Path):
+    if ctx.resilient_parsing:
+        return
+
+    config = NETDBConfig(config_path=config_path)
+    ctx.obj = config
+
+    default_endpoint = config.default_endpoint
+    # if we have no endpoint in config, we can abort here
+    if default_endpoint is None:
+        return
+
+    ctx.default_map = ctx.default_map or {}  # preserve existing defaults
+    ctx.default_map['netdb_endpoint'] = default_endpoint
+
+    ctx.default_map.update(_get_defaults(config, default_endpoint))
+
+
+def netdb_endpoint_callback(ctx: click.Context, _param: click.Parameter, endpoint: str) -> Optional[str]:
+    if ctx.resilient_parsing:
+        return
+
+    config = ctx.find_object(NETDBConfig)
+    if config is None:
+        raise click.ClickException('Could not find config object in context. This should not happen.')
+    ctx.default_map = ctx.default_map or {}  # preserve existing defaults
+
+    ctx.default_map.update(_get_defaults(config, endpoint))
+
+    return endpoint
+
+
+def netdb_config_option(*param_decls, **kwargs):
+    if not param_decls:
+        param_decls = ('--netdb-config', 'netdb_config')
+
+    kwargs.setdefault('callback', netdb_config_callback)
+    kwargs.setdefault('is_eager', True)
+    kwargs.setdefault('type', click.Path(path_type=Path))
+    kwargs.setdefault('default', Path('~/.config/netdb_client.ini'))
+    kwargs.setdefault('show_default', True)
+    kwargs.setdefault('expose_value', False)
+    kwargs.setdefault('help', 'netdb auth config file path')
+
+    return click.option(*param_decls, **kwargs)
+
+
+def netdb_endpoint_option(*param_decls, **kwargs):
+    if not param_decls:
+        param_decls = ('--netdb-endpoint', 'netdb_endpoint')
+
+    kwargs.setdefault('callback', netdb_endpoint_callback)
+    kwargs.setdefault('type', click.STRING)
+    kwargs.setdefault('envvar', 'NETDB_ENDPOINT')
+    kwargs.setdefault('show_envvar', True)
+    kwargs.setdefault('show_default', True)
+    kwargs.setdefault('expose_value', False)
+    kwargs.setdefault('help', 'endpoint to use. Config: [DEFAULT]: endpoint')
+
+    return click.option(*param_decls, **kwargs)
+
+
+def netdb_base_url_option(*param_decls, **kwargs):
+    if not param_decls:
+        param_decls = ('--netdb-base-url', 'netdb_base_url')
+
+    kwargs.setdefault('type', click.STRING)
+    kwargs.setdefault('envvar', 'NETDB_BASE_URL')
+    kwargs.setdefault('show_envvar', True)
+    kwargs.setdefault('show_default', True)
+    kwargs.setdefault('help', 'webapi server. Config: [$endpoint]: base_url')
+
+    return click.option(*param_decls, **kwargs)
+
+
+def netdb_token_option(*param_decls, **kwargs):
+    if not param_decls:
+        param_decls = ('--netdb-token', 'netdb_token')
+
+    kwargs.setdefault('type', click.STRING)
+    kwargs.setdefault('envvar', 'NETDB_TOKEN')
+    kwargs.setdefault('show_envvar', True)
+    kwargs.setdefault('show_default', False)
+    kwargs.setdefault('help', 'user API token. Config: [$endpoint]: token')
+
+    return click.option(*param_decls, **kwargs)
+
+
+def netdb_api_options(client_lib_module: types.ModuleType, target: str = 'netdb_api_endpoint'):
+    def decorator(func):
+        @netdb_config_option()
+        @netdb_endpoint_option()
+        @netdb_base_url_option()
+        @netdb_token_option()
+        def _decorator(*args, **kwargs):
+            api_endpoint = client_lib_module.APIEndpoint(base_url=kwargs.pop('netdb_base_url'), token=kwargs.pop('netdb_token'))
+            kwargs[target] = api_endpoint
+            return func(*args, **kwargs)
+
+        return update_wrapper(_decorator, func)
+
+    return decorator

netdb_client/util/config.py

+import configparser
+import stat
+
+
+class NETDBConfigError(Exception):
+    pass
+
+
+class NETDBConfig:
+    def __init__(self, config_path):
+        self.config = configparser.ConfigParser()
+        config_path_expanded = config_path.expanduser()
+        if config_path_expanded.is_file():
+            if config_path_expanded.stat().st_mode & stat.S_IRWXO:
+                raise NETDBConfigError(
+                    'Config file is readable by others. Please set it at least to 600 but never other-readable.'
+                )
+            self.config.read(config_path_expanded)
+
+        self.default_endpoint = self.config.get('DEFAULT', 'endpoint', fallback=None)
+
+    def endpoint(self, endpoint: str = None) -> str:
+        if endpoint is None:
+            endpoint = self.default_endpoint
+
+        if endpoint is None:
+            raise NETDBConfigError('No endpoint was provided.')
+
+        return endpoint
+
+    def base_url(self, endpoint: str = None) -> str:
+        base_url = self.config.get(self.endpoint(endpoint), 'base_url', fallback=None)
+
+        if base_url is None:
+            base_url = endpoint
+
+        return base_url
+
+    def token(self, endpoint: str = None) -> str:
+        token = self.config.get(self.endpoint(endpoint), 'token', fallback=None)
+
+        if token is None:
+            raise NETDBConfigError('No token was provided')
+
+        return token

pyproject.toml

 [build-system]
-# Minimum requirements for the build system to execute.
-requires = ["setuptools", "wheel", "net_api_generator @ git+https://gitlab.kit.edu/scc-net/netvs/api-generator.git@main", "semver", "requests"]
+requires = ["setuptools", "wheel", "semver", "requests", "net_api_generator @ git+https://gitlab.kit.edu/scc-net/netvs/api-generator.git@main"]
 build-backend = "setuptools.build_meta"
+
+[project]
+name = 'netdb_client'
+authors = [{name = 'NETVS Team', email = 'netvs@scc.kit.edu'}]
+description = 'This is a meta package to install the automatically generated NET-API definitions for the currently supported API versions.'
+requires-python = ">=3.7"
+license = {file = "LICENSE"}
+dependencies = [
+    "requests",
+]
+dynamic = ["version"]
+
+[project.urls]
+homepage = 'https://gitlab.kit.edu/scc-net/netvs/netdb-client'
+
+[tool.setuptools.packages.find]
+include = ["netdb_client*"]

setup.py

@@ -4,13 +4,17 @@ import subprocess
 import os
 import requests
 import semver
-        
-vers = requests.get(f"{os.environ.get('NETDB_SCHEME', 'https')}://{os.environ.get('NETDB_ENDPOINT')}").json()[0]
+from importlib.metadata import version
+
+
+vers = requests.get(
+    f"{os.environ.get('NETDB_SCHEME', 'https')}://{os.environ.get('NETDB_ENDPOINT', 'api.netdb.scc.kit.edu')}"
+).json()[0]
 largest_ver = None
 for v in vers:
     sem_v = semver.Version.parse(v['numeric'])
     if largest_ver is None or largest_ver < sem_v:
-        largest_ver = sem_v 
+        largest_ver = sem_v
 
 latest_previous_util_version = os.environ.get('LATEST_UTIL_VERSION', None)
 latest_previous_api_version = os.environ.get('LATEST_API_VERSION', None)
@@ -18,25 +22,28 @@ post_version = os.environ.get('POST_NUM', None)
 if post_version is not None and not post_version.isdigit():
     post_version = None
 
+
 def get_gen_version():
-    ver = subprocess.run(["pip freeze | grep net_api_generator"], shell=True, text=True, check=True, capture_output=True).stdout
-    return ver.split('@')[-1][:12]
+    ver = version('net_api_generator')
+    return ver.split('+')[-1]
+
 
 class APIGenBuild(build_py):
     def run(self):
         build_versions = [f'{v["major"]}.{v["minor"]}' for v in vers]
         default_version = f'{largest_ver.major}.{largest_ver.minor}'
         environ = os.environ.copy()
-        for version in build_versions:
-            target_dir = os.path.join(self.build_lib, 'netdb_client', f"api{version.replace('.', '')}")
+        for b_version in build_versions:
+            target_dir = os.path.join(self.build_lib, 'netdb_client', f"api{b_version.replace('.', '')}")
             self.mkpath(target_dir)
-            environ['NETDB_VERSION'] = version
+            environ['NETDB_VERSION'] = b_version
             subprocess.run(['net-api-generator', 'python', f'--output-dir={target_dir}'], check=True, env=environ)
         target_dir = os.path.join(self.build_lib, 'netdb_client')
         environ['NETDB_VERSION'] = default_version
         subprocess.run(['net-api-generator', 'python', f'--output-dir={target_dir}'], check=True, env=environ)
         build_py.run(self)
 
+
 util_version = f'{os.environ.get("CI_COMMIT_SHORT_SHA", "HEAD")}.{get_gen_version()}'
 
 if util_version != latest_previous_util_version and str(largest_ver) == latest_previous_api_version:
@@ -44,16 +51,10 @@ if util_version != latest_previous_util_version and str(largest_ver) == latest_p
         post_version = 1
     else:
         post_version = int(post_version) + 1
+if str(largest_ver) != latest_previous_api_version:
+    post_version = None
 
 setup(
-    name='netdb_client',
     version=f'{str(largest_ver)}{".post" + str(post_version) if post_version is not None else ""}{".dev1" if os.environ.get("CI_COMMIT_BRANCH", "local") == "devel" else ""}+{util_version}',
-    author='NETVS-Team <netvs@scc.kit.edu>',
-    description='This is a meta package to install the automatically generated NET-API definitions for the currently supported API versions.',
-    url='https://gitlab.kit.edu/scc-net/netvs/netdb-client',
-    install_requires=['requests'],
-    python_requires='>=3.7',
-    packages=['netdb_client'],
-    cmdclass={'build_py': APIGenBuild}
+    cmdclass={'build_py': APIGenBuild},
 )
-