def prepare_ci_env(c):
"""
Prepare CI environment
"""
title("Creating virtual env", "=")
c.run("python -m venv --clear dist_venv")
activate_venv(c, "dist_venv")
c.run("dist_venv/bin/python -m pip install -U setuptools wheel pip")
title("Building wheel", "=")
c.run("dist_venv/bin/python setup.py build bdist_wheel")
title("Installing wheel", "=")
package_version = read_configuration("./setup.cfg")["metadata"]["version"]
dist = next(Path("dist").glob(f"aiohttp_pydantic-{package_version}-*.whl"))
c.run(f"dist_venv/bin/python -m pip install {dist}")
# We verify that aiohttp-pydantic module is importable before installing CI tools.
package_names = read_configuration("./setup.cfg")["options"]["packages"]
for package_name in package_names:
c.run(f"dist_venv/bin/python -I -c 'import {package_name}'")
title("Installing CI tools", "=")
c.run("dist_venv/bin/python -m pip install -r requirements/ci.txt")
def test_ignore_errors(self, tmpdir):
_, config = fake_env(
tmpdir,
'[metadata]\n' 'version = attr: none.VERSION\n' 'keywords = one, two\n',
)
with pytest.raises(ImportError):
read_configuration('%s' % config)
config_dict = read_configuration('%s' % config, ignore_option_errors=True)
assert config_dict['metadata']['keywords'] == ['one', 'two']
assert 'version' not in config_dict['metadata']
config.remove()
def run(self):
dist = self.distribution
#homepage = dist.get_url()
#appname = self._parser.prog
appname = 'datalad'
cfg = read_configuration(opj(dirname(dirname(__file__)),
'setup.cfg'))['metadata']
sections = {
'Authors':
"""{0} is developed by {1} <{2}>.""".format(
appname, cfg['author'], cfg['author_email']),
}
for cls, opath, ext in ((fmt.ManPageFormatter, self.manpath, '1'),
(fmt.RSTManPageFormatter, self.rstpath,
'rst')):
if not os.path.exists(opath):
os.makedirs(opath)
for cmdname in getattr(self, 'cmdline_names', list(self._parser)):
if hasattr(self, 'cmdlist') and cmdname not in self.cmdlist:
continue
p = self._parser[cmdname]
cmdname = "{0}{1}".format(
'datalad ' if cmdname != 'datalad' else '', cmdname)
format = cls(cmdname,
ext_sections=sections,
version=versioneer.get_version())
formatted = format.format_man_page(p)
with open(
opj(opath, '{0}.{1}'.format(cmdname.replace(' ', '-'),
ext)), 'w') as f:
f.write(formatted)
def requirements_from_setup_cfg(
package_root: pathlib.Path,
options: Dict,
env: sphinx.environment.BuildEnvironment,
extra: str,
) -> List[str]:
"""
Load requirements from a ``setup.cfg`` file in the root of the repository.
:param package_root: The path to the package root.
:param options:
:param env:
:param extra: The name of the "extra" that the requirements are for.
:return: List of requirements.
"""
setup_cfg_file = PathPlus(env.srcdir).parent / "setup.cfg"
assert setup_cfg_file.is_file()
setup_cfg = read_configuration(setup_cfg_file)
if "options" in setup_cfg and "extras_require" in setup_cfg["options"]:
if extra in setup_cfg["options"]["extras_require"]:
return setup_cfg["options"]["extras_require"][extra]
else:
raise ValueError(
f"'{extra}' not found in '[options.extras_require]'")
else:
raise ValueError(
"'options.extras_require' section not found in 'setup.cfg")
def _get_setup_cfg(source_path: str) -> dict:
"""Method responsible to extract the setup.cfg metadata
:param source_path: Path to the folder where is located the sdist
files unpacked
:return: Metadata of setup.cfg
"""
from setuptools.config import read_configuration
log.debug(f"Started setup.cfg from {source_path}")
print_msg("Recovering metadata from setup.cfg")
path_setup_cfg = list(Path(source_path).rglob("setup.cfg"))
if not path_setup_cfg:
return {}
path_setup_cfg = path_setup_cfg[0]
setup_cfg = read_configuration(str(path_setup_cfg))
setup_cfg = dict(setup_cfg)
if setup_cfg.get("options", {}).get("python_requires"):
setup_cfg["options"]["python_requires"] = str(
setup_cfg["options"]["python_requires"])
result = {}
result.update(setup_cfg.get("options", {}))
result.update(setup_cfg.get("metadata", {}))
if result.get("build_ext"):
result["compilers"] = ["c"]
log.debug(f"Data recovered from setup.cfg: {result}")
return result
def get_python_versions() -> List[str]:
cfg = read_configuration("setup.cfg")
python_versions = []
for clsfr in cfg["metadata"]["classifiers"]:
if m := re.fullmatch(r'Programming Language :: Python :: (\d+\.\d+)',
clsfr):
python_versions.append(m[1])
def _extract_version(package_name):
try:
return pkg_resources.get_distribution(package_name).version
except pkg_resources.DistributionNotFound:
_conf = read_configuration(
path.join(path.dirname(path.dirname(__file__)), 'setup.cfg'))
return _conf['metadata']['version']
def setup_command():
cur_dir = '/'.join(dir_name.split(os.sep))
command = 'pyinstaller -y '
command += '--clean '
command += '-F ' # onefile
command += '-n "lncrawl" '
command += '-i "%s/res/lncrawl.ico" ' % cur_dir
config = read_configuration('setup.cfg')
sep = ';' if platform.system() == 'Windows' else ':'
for k, paths in config['options']['package_data'].items():
for v in paths:
src = os.path.normpath('/'.join([cur_dir, k, v]))
src = '/'.join(src.split(os.sep))
dst = os.path.normpath('/'.join([k, v]))
dst = os.path.dirname(dst)
dst = '/'.join(dst.split(os.sep))
dst = (dst + '/') if dst else '.'
command += '--add-data "%s%s%s" ' % (src, sep, dst)
# end for
# end for
command += '"%s/__main__.py" ' % cur_dir
print(command)
print()
extra = ['--distpath', os.path.join(dir_name, 'dist')]
extra += ['--workpath', os.path.join(output, 'build')]
extra += ['--specpath', output]
sys.argv = shlex.split(command) + extra
def setup(**kwargs):
"""
A wrapper around setuptools' setup() function that automatically sets up
custom commands, generates a version file, and customizes the setup process
via the ``setup_package.py`` files.
"""
# DEPRECATED: store the package name in a built-in variable so it's easy
# to get from other parts of the setup infrastructure. We should phase this
# out in packages that use it - the cookiecutter template should now be
# able to put the right package name where needed.
conf = read_configuration('setup.cfg')
builtins._ASTROPY_PACKAGE_NAME_ = conf['metadata']['name']
# Create a dictionary with setup command overrides. Note that this gets
# information about the package (name and version) from the setup.cfg file.
cmdclass = register_commands()
# Freeze build information in version.py. Note that this gets information
# about the package (name and version) from the setup.cfg file.
version = generate_version_py()
# Get configuration information from all of the various subpackages.
# See the docstring for setup_helpers.update_package_files for more
# details.
package_info = get_package_info()
package_info['cmdclass'] = cmdclass
package_info['version'] = version
# Override using any specified keyword arguments
package_info.update(kwargs)
setuptools_setup(**package_info)
def get_setup_cfg(_, extracted_files: Iterable[str]) -> Any:
setup_cfg_candidates = [
filepath for filepath in extracted_files
if os.path.basename(filepath) == "setup.cfg"
]
if setup_cfg_candidates:
return read_configuration(setup_cfg_candidates[0])
def setup(**kwargs):
"""
A wrapper around setuptools' setup() function that automatically sets up
custom commands, generates a version file, and customizes the setup process
via the ``setup_package.py`` files.
"""
# DEPRECATED: store the package name in a built-in variable so it's easy
# to get from other parts of the setup infrastructure. We should phase this
# out in packages that use it - the cookiecutter template should now be
# able to put the right package name where needed.
conf = read_configuration('setup.cfg')
builtins._ASTROPY_PACKAGE_NAME_ = conf['metadata']['name']
# Create a dictionary with setup command overrides. Note that this gets
# information about the package (name and version) from the setup.cfg file.
cmdclass = register_commands()
# Freeze build information in version.py. Note that this gets information
# about the package (name and version) from the setup.cfg file.
version = generate_version_py()
# Get configuration information from all of the various subpackages.
# See the docstring for setup_helpers.update_package_files for more
# details.
package_info = get_package_info()
package_info['cmdclass'] = cmdclass
package_info['version'] = version
# Override using any specified keyword arguments
package_info.update(kwargs)
setuptools_setup(**package_info)
async def async_cli():
parser = ArgumentParser(
description='Generate requirements.nix from dependencies')
parser.add_argument('--python-target',
'-V',
required=True,
help='Major python version')
args = parser.parse_args()
target = TargetDetails(args.python_target)
requirements = set()
configuration = read_configuration('setup.cfg')
for dep in configuration['options'].get('setup_requires', []):
requirements.add(RequirementWrapper.from_requirement(dep))
for dep in configuration['options'].get('tests_require', []):
requirements.add(RequirementWrapper.from_requirement(dep))
for dep in configuration['options'].get('install_requires', []):
requirements.add(RequirementWrapper.from_requirement(dep))
for extra in configuration['options'].get('extras', {}).values():
for dep in extra:
requirements.add(RequirementWrapper.from_requirement(dep))
solver = DependencySolver(requirements, target)
await solver.run()
write_requirements('requirements.nix', solver.candidates)
def load_setup_py_data_basic(setup_file, work_dir=None):
_setuptools_data = {}
import setuptools
cd_to_work = False
path_backup = sys.path
def _change_cwd(target_dir):
cd_to_work = True
try:
cwd = os.getcwd()
except OSError:
cwd = recipe_dir or work_dir
os.chdir(target_dir)
# this is very important - or else if versioneer or otherwise is in the start folder,
# things will pick up the wrong versioneer/whatever!
sys.path.insert(0, target_dir)
return cd_to_work, cwd
setup_cfg_data = {}
try:
from setuptools.config import read_configuration
except ImportError:
pass # setuptools <30.3.0 cannot read metadata / options from 'setup.cfg'
else:
setup_cfg = os.path.join(os.path.dirname(setup_file), 'setup.cfg')
if os.path.isfile(setup_cfg):
# read_configuration returns a dict of dicts. Each dict (keys: 'metadata',
# 'options'), if present, provides keyword arguments for the setup function.
for kwargs in read_configuration(setup_cfg).values():
# explicit arguments to setup.cfg take priority over values in setup.py
setup_cfg_data.update(kwargs)
def setup(**kw):
_setuptools_data.update(kw)
# values in setup.cfg take priority over explicit arguments to setup.py
_setuptools_data.update(setup_cfg_data)
# Patch setuptools, distutils
setuptools_setup = setuptools.setup
setuptools.setup = setup
ns = {
'__name__': '__main__',
'__doc__': None,
'__file__': setup_file,
}
if os.path.isfile(setup_file):
with open(setup_file) as f:
code = compile(f.read(), setup_file, 'exec', dont_inherit=1)
exec(code, ns, ns)
setuptools.setup = setuptools_setup
if cd_to_work: os.chdir(cwd)
# remove our workdir from sys.path
sys.path = path_backup
return _setuptools_data
def inspect_project(dirpath: Optional[Union[str, Path]] = None) -> dict:
"""Fetch various information about an already-initialized project"""
if dirpath is None:
directory = Path()
else:
directory = Path(dirpath)
def exists(*fname: str) -> bool:
return Path(directory, *fname).exists()
if not exists("pyproject.toml"):
raise InvalidProjectError("Project is missing pyproject.toml file")
if not exists("setup.cfg"):
raise InvalidProjectError("Project is missing setup.cfg file")
if not exists("src"):
raise InvalidProjectError("Project does not have src/ layout")
cfg = read_configuration(str(directory / "setup.cfg"))
env = {
"name": cfg["metadata"]["name"],
"short_description": cfg["metadata"]["description"],
"author": cfg["metadata"]["author"],
"author_email": cfg["metadata"]["author_email"],
"python_requires": util.sort_specifier(cfg["options"]["python_requires"]),
"install_requires": cfg["options"].get("install_requires", []),
# Until <https://github.com/pypa/setuptools/issues/2575> is fixed, we
# have to determine versions via read_version() instead of
# read_configuration().
# "version": cfg["metadata"].get("version"),
"keywords": cfg["metadata"].get("keywords", []),
"supports_pypy3": False,
"default_branch": git.Git(dirpath=directory).get_default_branch(),
}
# if env["version"] is None:
# raise InvalidProjectError("Cannot determine project version")
if cfg["options"].get("packages"):
env["is_flat_module"] = False
env["import_name"] = cfg["options"]["packages"][0]
initfile = directory / "src" / env["import_name"] / "__init__.py"
else:
env["is_flat_module"] = True
env["import_name"] = cfg["options"]["py_modules"][0]
initfile = directory / "src" / (env["import_name"] + ".py")
try:
env["version"] = versioningit.get_version(directory)
env["uses_versioningit"] = True
except versioningit.NotVersioningitError:
env["version"] = read_version(initfile.resolve())
env["uses_versioningit"] = False
env["python_versions"] = []
for clsfr in cfg["metadata"]["classifiers"]:
if m := re.fullmatch(r"Programming Language :: Python :: (\d+\.\d+)", clsfr):
env["python_versions"].append(util.PyVersion.parse(m[1]))
if clsfr == "Programming Language :: Python :: Implementation :: PyPy":
env["supports_pypy3"] = True
def check_setup_cfg():
"""Check setup.cfg"""
check_path("setup.cfg")
errors = 0
setup_config = read_configuration(os.path.join(ROOT_DIR, "setup.cfg"))
# parse data from setup.cfg
classifiers = setup_config["metadata"]["classifiers"]
install_requires = setup_config["options"]["install_requires"]
# validate that we have the proper language/django classifiers
pyver_cfs = [
m.groups(0)[0] for m in filter(
None,
[re.search(r"Python :: (3\.[0-9]+)$", cf) for cf in classifiers])
]
if pyver_cfs != CONFIG["python-major"]:
errors += err(
f'Wrong python classifiers: Have {pyver_cfs}, wanted {CONFIG["python-major"]}'
)
djver_cfs = [
m.groups(0)[0] for m in filter(None, [
re.search(r"Django :: ([0-9]\.[0-9]+)$", cf) for cf in classifiers
])
]
if djver_cfs != CONFIG["django-major"]:
errors += err(
f'Wrong python classifiers: Have {djver_cfs}, wanted {CONFIG["django-major"]}'
)
for djver in CONFIG["django-map"]:
if f"Framework :: Django :: {djver}" not in classifiers:
errors += err(f"Django {djver} classifier not found.")
expected_py_req = f">={CONFIG['python-major'][0]}"
actual_py_req = setup_config["options"]["python_requires"]
if actual_py_req != expected_py_req:
errors += err(
f"python_requires: Have {actual_py_req}, expected {expected_py_req}"
)
expected_django_req = f"Django>={CONFIG['django-major'][0]}"
if expected_django_req not in install_requires:
errors += err(
f"{expected_django_req}: Expected Django requirement not found.")
expected_cg_req = f"cryptography>={CONFIG['cryptography-major'][0]}"
if expected_cg_req not in install_requires:
errors += err(
f"{expected_cg_req}: Expected cryptography requirement not found.")
# Do not check setup.cfg minimum dependency, as actually any version works fine right now
# expected_idna_req = f"idna>={CONFIG['idna-major'][0]}"
# if expected_idna_req not in install_requires:
# errors += err(f"{expected_idna_req}: Expected idna requirement not found.")
return errors
def major_minor_version(cls):
"""Find the major minor declared in the setup.cfg."""
try:
config = read_configuration("setup.cfg")
except DistutilsFileError:
raise FileNotFoundError("setup.cfg")
return version.parse(config["metadata"]["version"])
def test_ignore_errors(self, tmpdir):
_, config = fake_env(
tmpdir,
'[metadata]\n'
'version = attr: none.VERSION\n'
'keywords = one, two\n'
)
with pytest.raises(ImportError):
read_configuration('%s' % config)
config_dict = read_configuration(
'%s' % config, ignore_option_errors=True)
assert config_dict['metadata']['keywords'] == ['one', 'two']
assert 'version' not in config_dict['metadata']
config.remove()
def extractFromSetupCfg(setupCfgPath: Path) -> typing.Optional[str]:
from setuptools.config import read_configuration
setupCfg = read_configuration(setupCfgPath)
try:
return setupCfg["metadata"]["name"]
except KeyError:
return None
def tag_eq_version(c):
"""
Ensure that the last git tag matches the package version
"""
git_tag = c.run("git describe --tags HEAD", hide=True).stdout.strip()
package_version = read_configuration("./setup.cfg")["metadata"]["version"]
if git_tag != f"v{package_version}":
raise Exit(f"ERROR: The git tag {git_tag!r} does not matches"
f" the package version {package_version!r}")
def get_configuration(setup_cfg):
"""
Read the setup.cfg file.
:param setup_cfg: The path of the setup.cfg file
:returns: The configuration data
:rtype: dict
"""
return read_configuration(str(setup_cfg))
def _extract_version(package_name):
"""
Get package version from installed distribution or configuration file if not
installed
"""
try:
return pkg_resources.get_distribution(package_name).version
except pkg_resources.DistributionNotFound:
_conf = read_configuration(os.path.join(PROJECT_DIR, "setup.cfg"))
return _conf["metadata"]["version"]
def _extract_version(package_name):
try:
import pkg_resources
return pkg_resources.get_distribution(package_name).version
except pkg_resources.DistributionNotFound:
from setuptools.config import read_configuration
from os import path as _p
_conf = read_configuration(
_p.join(_p.dirname(_p.dirname(__file__)), "setup.cfg"))
return _conf["metadata"]["version"]
def __init__(
self,
setup_cfg_path: str,
logger: Logger,
requirement_parser: RequirementParser,
):
self.setup_cfg_path = setup_cfg_path
self.setup_cfg = read_configuration(setup_cfg_path)
self.logger = logger
self.requirement_parser = requirement_parser
def _extract_version(package_name):
"""
Get package version from installed distribution or configuration file if not
installed
"""
try:
return pkg_resources.get_distribution(package_name).version
except pkg_resources.DistributionNotFound:
_conf = read_configuration(os.path.join(PROJECT_DIR, "setup.cfg"))
return _conf["metadata"]["version"]
def cli(sections, input, output, quiet):
# Set YAML parameters
yaml = YAML(typ="rt") # Round-trip mode allows for comment insertion
indent_offset = 2
yaml.indent(offset=indent_offset)
# Load environment file template
with open(os.path.join("requirements", "environment.in")) as f:
env_yml = yaml.load(f.read())
# Extract dependency section contents
if not quiet:
print(f"Reading dependencies from {input}")
setup_config = read_configuration(input)
sections = [x.strip() for x in sections.split(",")]
section_indices = dict()
dep_list = (deepcopy(env_yml["dependencies"])
if "dependencies" in env_yml else [])
i = len(dep_list)
for section in sections:
section_indices[section] = i
try:
packages = (setup_config["options"]["install_requires"]
if section == "main" else
setup_config["options"]["extras_require"][section])
except KeyError:
raise RuntimeError(f"Cannot fetch dependencies from {input}")
for package in packages:
if package not in dep_list: # Do not duplicate
dep_list.append(package)
i += 1
# Format dependency list
lst = CS(dep_list)
for section, i in section_indices.items():
lst.yaml_set_comment_before_after_key(i, section, indent_offset)
env_yml["dependencies"] = lst
# Output to terminal
if not quiet:
yaml.dump(env_yml, sys.stdout)
# Output to file
if output is not None:
with open(output, "w") as outfile:
if not quiet:
print()
print(f"Saving to {output}")
yaml.dump(env_yml, outfile)
def set_version():
here = os.path.abspath(os.path.dirname(__file__))
config = read_configuration(os.path.join(here, "setup.cfg"))
version = config["metadata"]["version"]
try:
branch_name = os.environ["BRANCH_NAME"]
if branch_name != "dev" and "dev" in version:
version += "-" + branch_name
except KeyError:
pass
return version
def _extract_version(package_name):
try:
# if package is installed
version = pkg_resources.get_distribution(package_name).version
except pkg_resources.DistributionNotFound:
# if not installed, so we must be in source, with ``setup.cfg`` available
_conf = read_configuration(
path.join(path.dirname(__file__), '..', 'setup.cfg'))
version = _conf['metadata']['version']
return version
def _extract_version(package_name):
try:
# if package is installed
version = pkg_resources.get_distribution(package_name).version
except pkg_resources.DistributionNotFound:
# if not installed, so we must be in source, with ``setup.cfg`` available
_conf = read_configuration(path.join(
path.dirname(__file__), '..', 'setup.cfg')
)
version = _conf['metadata']['version']
return version
def _extract_version(package_name):
"""
Extract fonzie version.
Get package version from installed distribution or configuration file if not installed
"""
try:
return pkg_resources.get_distribution(package_name).version
except pkg_resources.DistributionNotFound:
_conf = read_configuration(
path.join(path.dirname(path.dirname(__file__)), 'setup.cfg'))
return _conf['metadata']['version']
def test_basic(self, tmpdir):
_, config = fake_env(
tmpdir, '[metadata]\n'
'version = 10.1.1\n'
'keywords = one, two\n'
'\n'
'[options]\n'
'scripts = bin/a.py, bin/b.py\n')
config_dict = read_configuration('%s' % config)
assert config_dict['metadata']['version'] == '10.1.1'
assert config_dict['metadata']['keywords'] == ['one', 'two']
assert config_dict['options']['scripts'] == ['bin/a.py', 'bin/b.py']
def _extract_version(package_name):
try:
# if package is installed
version = pkg_resources.get_distribution(package_name).version
except pkg_resources.DistributionNotFound:
# if not installed, so we must be in source, with ``setup.cfg`` available
from setuptools.config import read_configuration
_conf = read_configuration(
path.join(path.dirname(__file__), 'setup.cfg'))
version = _conf['metadata']['version']
return tuple(int(part) for part in version.split('.') if part.isnumeric())
def _extract_version(package_name):
try:
# if package is installed
version = pkg_resources.get_distribution(package_name).version
except pkg_resources.DistributionNotFound:
# if not installed, so we must be in source, with ``setup.cfg`` available
from setuptools.config import read_configuration
_conf = read_configuration(path.join(
path.dirname(__file__), 'setup.cfg')
)
version = _conf['metadata']['version']
return tuple(int(part) for part in version.split('.') if part.isnumeric())
def test_basic(self, tmpdir):
_, config = fake_env(
tmpdir,
'[metadata]\n'
'version = 10.1.1\n'
'keywords = one, two\n'
'\n'
'[options]\n'
'scripts = bin/a.py, bin/b.py\n'
)
config_dict = read_configuration('%s' % config)
assert config_dict['metadata']['version'] == '10.1.1'
assert config_dict['metadata']['keywords'] == ['one', 'two']
assert config_dict['options']['scripts'] == ['bin/a.py', 'bin/b.py']
def load_setup_py_data_basic(setup_file, work_dir=None):
_setuptools_data = {}
import setuptools
cd_to_work = False
path_backup = sys.path
os.chdir(work_dir)
setup_cfg_data = {}
try:
from setuptools.config import read_configuration
except ImportError:
pass # setuptools <30.3.0 cannot read metadata / options from 'setup.cfg'
else:
setup_cfg = os.path.join(os.path.dirname(setup_file), "setup.cfg")
if os.path.isfile(setup_cfg):
# read_configuration returns a dict of dicts. Each dict (keys: 'metadata',
# 'options'), if present, provides keyword arguments for the setup function.
for kwargs in read_configuration(setup_cfg).values():
# explicit arguments to setup.cfg take priority over values in setup.py
setup_cfg_data.update(kwargs)
def setup(**kw):
_setuptools_data.update(kw)
# values in setup.cfg take priority over explicit arguments to setup.py
_setuptools_data.update(setup_cfg_data)
# Patch setuptools, distutils
setuptools_setup = setuptools.setup
setuptools.setup = setup
ns = {
"__name__": "__main__",
"__doc__": None,
"__file__": setup_file,
}
if os.path.isfile(setup_file):
with open(setup_file) as f:
code = compile(f.read(), setup_file, "exec", dont_inherit=1)
exec(code, ns, ns)
setuptools.setup = setuptools_setup
if cd_to_work:
os.chdir(cwd)
# remove our workdir from sys.path
sys.path = path_backup
return _setuptools_data
def upload(c, pypi_user=None, pypi_password=None):
"""
Upload on pypi
"""
package_version = read_configuration("./setup.cfg")["metadata"]["version"]
dist = next(Path("dist").glob(f"aiohttp_pydantic-{package_version}-*.whl"))
if pypi_user is not None and pypi_password is not None:
c.run(
f"dist_venv/bin/twine upload --non-interactive"
f" -u {pypi_user} -p {pypi_password} {dist}",
hide=True,
)
else:
c.run(
f"dist_venv/bin/twine upload --repository aiohttp-pydantic {dist}")
def load_setup_py_data_basic(setup_file, work_dir=None):
_setuptools_data = {}
import setuptools
cd_to_work = False
path_backup = sys.path
os.chdir(work_dir)
setup_cfg_data = {}
try:
from setuptools.config import read_configuration
except ImportError:
pass # setuptools <30.3.0 cannot read metadata / options from 'setup.cfg'
else:
setup_cfg = os.path.join(os.path.dirname(setup_file), 'setup.cfg')
if os.path.isfile(setup_cfg):
# read_configuration returns a dict of dicts. Each dict (keys: 'metadata',
# 'options'), if present, provides keyword arguments for the setup function.
for kwargs in read_configuration(setup_cfg).values():
# explicit arguments to setup.cfg take priority over values in setup.py
setup_cfg_data.update(kwargs)
def setup(**kw):
_setuptools_data.update(kw)
# values in setup.cfg take priority over explicit arguments to setup.py
_setuptools_data.update(setup_cfg_data)
# Patch setuptools, distutils
setuptools_setup = setuptools.setup
setuptools.setup = setup
ns = {
'__name__': '__main__',
'__doc__': None,
'__file__': setup_file,
}
if os.path.isfile(setup_file):
with open(setup_file) as f:
code = compile(f.read(), setup_file, 'exec', dont_inherit=1)
exec(code, ns, ns)
setuptools.setup = setuptools_setup
if cd_to_work: os.chdir(cwd)
# remove our workdir from sys.path
sys.path = path_backup
return _setuptools_data
def _find_plugins():
subdirs = sorted(
Path(x) for x in next(os.walk('.'))[1] if x[0] != '.' and x != '_meta'
and os.path.exists(os.path.join(x, 'setup.cfg')))
for subdir in subdirs:
path = subdir / 'setup.cfg'
metadata = read_configuration(path)['metadata']
name = metadata['name']
version = metadata['version']
if name is None or version is None:
click.secho(f'Could not extract name/version from {path}',
fg='red',
bold=True)
continue
minver = str(Version(version))
yield name, minver
def createInitFile(dist=None, version=None, sha=None):
"""Create psychopy/__init__.py
:param:`dist` can be:
None:
writes __version__
'sdist':
for python setup.py sdist - writes git id (__git_sha__)
'bdist':
for python setup.py bdist - writes git id (__git_sha__)
and __build_platform__
"""
# get default values if None
if version is None:
with open(os.path.join(thisLoc,'version')) as f:
version = f.read().strip()
if sha is None:
sha = _getGitShaString(dist)
platformStr = _getPlatformString(dist)
metadata = read_configuration('setup.cfg')['metadata']
infoDict = {'version': version,
'author': metadata['author'],
'author_email': metadata['author_email'],
'maintainer_email': metadata['maintainer_email'],
'url': metadata['url'],
'download_url': metadata['download_url'],
'license': metadata['license'],
'shaStr': sha,
'platform': platformStr}
# write it
with open(os.path.join(thisLoc, 'psychopy','__init__.py'), 'w') as f:
outStr = template.format(**infoDict)
f.write(outStr)
print('wrote init for ', version, sha)
# and return it
return outStr
def test_no_config(self, tmpdir):
with pytest.raises(DistutilsFileError):
read_configuration('%s' % tmpdir.join('setup.cfg'))
import os
import sys
from setuptools import setup
from setuptools.config import read_configuration
from setuputils import find_version
def here(*paths):
return os.path.join(os.path.dirname(__file__), *paths)
config = read_configuration(here('setup.cfg'))
config['metadata']['version'] = find_version(here('astor', '__init__.py'))
config['options'].update(config['metadata'])
setup(**config['options'])
from astropy_helpers.setup_helpers import setup, register_commands # noqa
################################################################################
# Override the default Astropy Test Command
################################################################################
cmdclass = register_commands()
try:
from sunpy.tests.setup_command import SunPyTest
# Overwrite the Astropy Testing framework
cmdclass['test'] = type('SunPyTest', (SunPyTest,),
{'package_name': 'sunpy'})
except Exception:
# Catch everything, if it doesn't work, we still want SunPy to install.
pass
################################################################################
# Programmatically generate some extras combos.
################################################################################
extras = read_configuration("setup.cfg")['options']['extras_require']
# Dev is everything
extras['dev'] = list(chain(*extras.values()))
# All is everything but tests and docs
exclude_keys = ("tests", "docs", "dev")
ex_extras = dict(filter(lambda i: i[0] not in exclude_keys, extras.items()))
# Concatenate all the values together for 'all'
extras['all'] = list(chain.from_iterable(ex_extras.values()))
setup(extras_require=extras, cmdclass=cmdclass)
#!/usr/bin/env python3 from pathlib import Path from setuptools import setup from setuptools.config import read_configuration cfg = read_configuration(Path(__file__).parent / 'setup.cfg') #print(cfg) cfg["options"].update(cfg["metadata"]) cfg=cfg["options"] setup(use_scm_version = True, **cfg)
# Copyright (c) 2019 Ian C. Good
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
from setuptools import setup # type: ignore
from setuptools.config import read_configuration # type: ignore
conf_dict = read_configuration('setup.cfg')
setup(**conf_dict['metadata'], **conf_dict['options'])
# Licensed under a 3-clause BSD style license - see LICENSE.rst
import sys
from distutils.version import LooseVersion
# We require setuptools 30.3.0 or later for the configuration in setup.cfg to
# work properly.
import setuptools
if LooseVersion(setuptools.__version__) < LooseVersion('30.3.0'):
sys.stderr.write("ERROR: Astropy requires setuptools 30.3.0 or later "
"(found {0})".format(setuptools.__version__))
sys.exit(1)
from setuptools.config import read_configuration
conf = read_configuration('setup.cfg')
import os
import glob
import ah_bootstrap
from setuptools import setup
from astropy_helpers.setup_helpers import (
register_commands, get_package_info, get_debug_option)
from astropy_helpers.distutils_helpers import is_distutils_display_option
from astropy_helpers.git_helpers import get_git_devstr
from astropy_helpers.version_helpers import generate_version_py
import astropy
from setuptools import setup, find_packages
from setuptools.config import read_configuration
import os
from os.path import exists, join
from sys import platform, argv, version_info
PY3 = version_info >= (3, 0)
with open('version') as f:
version = f.read().strip()
#
# Special handling for Anaconda / Miniconda
#
required = read_configuration('setup.cfg')['options']['install_requires']
# OpenCV
# Naming conflict with PyPI package.
# `opencv` package should be installed via conda instead
if 'CONDA_PREFIX' in os.environ:
required.remove('opencv-python')
# PyQt
# Naming conflict with PyPI package.
# `pyqt` package should be installed via conda instead
# cf. https://github.com/ContinuumIO/anaconda-issues/issues/1554
if PY3 and 'CONDA_PREFIX' in os.environ:
required.remove('pyqt5; python_version >= "3"')
# for dev you also want:
import os from setuptools import setup from setuptools.config import read_configuration this_dir = os.path.dirname(__file__) cfg = read_configuration(os.path.join(this_dir, 'setup.cfg')) #print(cfg) cfg["options"].update(cfg["metadata"]) cfg = cfg["options"] setup(**cfg)
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
# Import asynctest source directory
sys.path.insert(0, os.path.abspath('..')) # NOQA
try:
from setuptools.config import read_configuration
cfg_path = os.path.join(os.path.dirname(__file__), '..', 'setup.cfg')
setup_args = read_configuration(cfg_path)['metadata']
except ImportError:
from setup import args as setup_args, read_version
setup_args["author"] = "Martin Richard"
setup_args["description"] = ""
setup_args["version"] = read_version()
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
def get_package_info(srcdir='.', exclude=()):
"""
Collates all of the information for building all subpackages
and returns a dictionary of keyword arguments that can
be passed directly to `distutils.setup`.
The purpose of this function is to allow subpackages to update the
arguments to the package's ``setup()`` function in its setup.py
script, rather than having to specify all extensions/package data
directly in the ``setup.py``. See Astropy's own
``setup.py`` for example usage and the Astropy development docs
for more details.
This function obtains that information by iterating through all
packages in ``srcdir`` and locating a ``setup_package.py`` module.
This module can contain the following functions:
``get_extensions()``, ``get_package_data()``,
``get_build_options()``, and ``get_external_libraries()``.
Each of those functions take no arguments.
- ``get_extensions`` returns a list of
`distutils.extension.Extension` objects.
- ``get_package_data()`` returns a dict formatted as required by
the ``package_data`` argument to ``setup()``.
- ``get_build_options()`` returns a list of tuples describing the
extra build options to add.
- ``get_external_libraries()`` returns
a list of libraries that can optionally be built using external
dependencies.
"""
ext_modules = []
packages = []
package_dir = {}
# Read in existing package data, and add to it below
setup_cfg = os.path.join(srcdir, 'setup.cfg')
if os.path.exists(setup_cfg):
conf = read_configuration(setup_cfg)
if 'options' in conf and 'package_data' in conf['options']:
package_data = conf['options']['package_data']
else:
package_data = {}
else:
package_data = {}
if exclude:
warnings.warn(
"Use of the exclude parameter is no longer supported since it does "
"not work as expected. Use add_exclude_packages instead. Note that "
"it must be called prior to any other calls from setup helpers.",
AstropyDeprecationWarning)
# Use the find_packages tool to locate all packages and modules
packages = find_packages(srcdir, exclude=exclude)
# Update package_dir if the package lies in a subdirectory
if srcdir != '.':
package_dir[''] = srcdir
# For each of the setup_package.py modules, extract any
# information that is needed to install them. The build options
# are extracted first, so that their values will be available in
# subsequent calls to `get_extensions`, etc.
for setuppkg in iter_setup_packages(srcdir, packages):
if hasattr(setuppkg, 'get_build_options'):
options = setuppkg.get_build_options()
for option in options:
add_command_option('build', *option)
if hasattr(setuppkg, 'get_external_libraries'):
libraries = setuppkg.get_external_libraries()
for library in libraries:
add_external_library(library)
for setuppkg in iter_setup_packages(srcdir, packages):
# get_extensions must include any Cython extensions by their .pyx
# filename.
if hasattr(setuppkg, 'get_extensions'):
ext_modules.extend(setuppkg.get_extensions())
if hasattr(setuppkg, 'get_package_data'):
package_data.update(setuppkg.get_package_data())
# Locate any .pyx files not already specified, and add their extensions in.
# The default include dirs include numpy to facilitate numerical work.
ext_modules.extend(get_cython_extensions(srcdir, packages, ext_modules,
['numpy']))
# Now remove extensions that have the special name 'skip_cython', as they
# exist Only to indicate that the cython extensions shouldn't be built
for i, ext in reversed(list(enumerate(ext_modules))):
if ext.name == 'skip_cython':
del ext_modules[i]
# On Microsoft compilers, we need to pass the '/MANIFEST'
# commandline argument. This was the default on MSVC 9.0, but is
# now required on MSVC 10.0, but it doesn't seem to hurt to add
# it unconditionally.
if get_compiler_option() == 'msvc':
for ext in ext_modules:
ext.extra_link_args.append('/MANIFEST')
return {
'ext_modules': ext_modules,
'packages': packages,
'package_dir': package_dir,
'package_data': package_data,
}
def load_setup_py_data(config, setup_file='setup.py', from_recipe_dir=False, recipe_dir=None,
permit_undefined_jinja=True):
_setuptools_data = {}
log = get_logger(__name__)
def setup(**kw):
_setuptools_data.update(kw)
import setuptools
import distutils.core
cd_to_work = False
path_backup = sys.path
if from_recipe_dir and recipe_dir:
setup_file = os.path.abspath(os.path.join(recipe_dir, setup_file))
elif os.path.exists(config.work_dir):
cd_to_work = True
cwd = os.getcwd()
os.chdir(config.work_dir)
if not os.path.isabs(setup_file):
setup_file = os.path.join(config.work_dir, setup_file)
# this is very important - or else if versioneer or otherwise is in the start folder,
# things will pick up the wrong versioneer/whatever!
sys.path.insert(0, config.work_dir)
else:
message = ("Did not find setup.py file in manually specified location, and source "
"not downloaded yet.")
if permit_undefined_jinja:
log.debug(message)
return {}
else:
raise RuntimeError(message)
# Patch setuptools, distutils
setuptools_setup = setuptools.setup
distutils_setup = distutils.core.setup
numpy_setup = None
versioneer = None
if 'versioneer' in sys.modules:
versioneer = sys.modules['versioneer']
del sys.modules['versioneer']
try:
import numpy.distutils.core
numpy_setup = numpy.distutils.core.setup
numpy.distutils.core.setup = setup
except ImportError:
log.debug("Failed to import numpy for setup patch. Is numpy installed?")
setuptools.setup = distutils.core.setup = setup
ns = {
'__name__': '__main__',
'__doc__': None,
'__file__': setup_file,
}
if os.path.isfile(setup_file):
try:
from setuptools.config import read_configuration
except ImportError:
pass # setuptools <30.3.0 cannot read metadata / options from 'setup.cfg'
else:
setup_cfg = os.path.join(os.path.dirname(setup_file), 'setup.cfg')
if os.path.isfile(setup_cfg):
# read_configuration returns a dict of dicts. Each dict (keys: 'metadata',
# 'options'), if present, provides keyword arguments for the setup function.
for kwargs in read_configuration(setup_cfg).values():
_setuptools_data.update(kwargs)
code = compile(open(setup_file).read(), setup_file, 'exec', dont_inherit=1)
exec(code, ns, ns)
else:
if not permit_undefined_jinja:
raise TypeError('{} is not a file that can be read'.format(setup_file))
sys.modules['versioneer'] = versioneer
distutils.core.setup = distutils_setup
setuptools.setup = setuptools_setup
if numpy_setup:
numpy.distutils.core.setup = numpy_setup
if cd_to_work:
os.chdir(cwd)
# remove our workdir from sys.path
sys.path = path_backup
return _setuptools_data if _setuptools_data else None
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("requirements", nargs="*")
parser.add_argument("--extras", default=[])
args = parser.parse_args()
if args.extras:
args.extras = set(args.extras.split(','))
options = {}
print('# AUTOGENERATED by {}\n# DO NOT EDIT\n#\n'.format(sys.argv[0]))
if os.path.exists('setup.cfg'):
options = read_configuration('setup.cfg').get('options', {})
install_requires = options.get('install_requires', [])
extras_require = options.get('extras_require', {})
if install_requires:
fname = 'setup.cfg:options.install_requires'
print_file(
fname,
(Requirement.parse(l) for l in sorted(install_requires)),
)
for extra, requires in sorted(extras_require.items()):
if extra in args.extras:
fname = 'setup.cfg:options.extras_require:' + extra
print_file(
except NoSectionError:
pass
opt['package_data'] = {}
for k, v in opt_package_data.items():
opt['package_data'][k] = cfg_val_to_list(v)
cur_pkgs = opt.get('packages', '').strip()
if '\n' in cur_pkgs:
opt['packages'] = cfg_val_to_list(opt['packages'])
elif cur_pkgs.startswith('find:'):
opt_packages_find = dict(cfg.items('options.packages.find'))
opt['packages'] = setuptools.find_packages(**opt_packages_find)
return {'metadata': md, 'options': opt}
setup_params = {}
declarative_setup_params = read_configuration('setup.cfg')
# Patch incorrectly decoded package_dir option
# ``egg_info`` demands native strings failing with unicode under Python 2
# Ref https://github.com/pypa/setuptools/issues/1136
if 'package_dir' in declarative_setup_params['options']:
declarative_setup_params['options']['package_dir'] = {
str(k): str(v)
for k, v in declarative_setup_params['options']['package_dir'].items()
}
setup_params = dict(setup_params, **declarative_setup_params['metadata'])
setup_params = dict(setup_params, **declarative_setup_params['options'])
__name__ == '__main__' and setuptools.setup(**setup_params)
# setup_requires and install_requires since these are determined
# programmatically.
import os
import builtins
import ah_bootstrap # noqa
from astropy_helpers.distutils_helpers import is_distutils_display_option
from astropy_helpers.setup_helpers import setup
from setuptools.config import read_configuration
# We set up the following variable because we then use this in astropy/__init__.py
# to make sure that we aren't importing astropy during the setup process (we used
# to do this)
builtins._ASTROPY_CORE_SETUP_ = True
if is_distutils_display_option():
# Avoid installing setup_requires dependencies if the user just
# queries for information
setup_requires = []
else:
setup_requires = read_configuration('setup.cfg')['options']['setup_requires']
# Make sure we have the packages needed for building astropy, but do not
# require them when installing from an sdist as the c files are included.
if not os.path.exists(os.path.join(os.path.dirname(__file__), 'PKG-INFO')):
setup_requires.extend(['cython>=0.21', 'jinja2>=2.7'])
setup(setup_requires=setup_requires)
