setup.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from typing import Sequence, List


def python_version_check(major=3, minor=6):
 import sys

 assert sys.version_info.major == major and sys.version_info.minor >= minor, (
 f"This project is utilises language features only present Python {major}.{minor} and greater. "
 f"You are running {sys.version_info}."
 )


python_version_check()

import pathlib
import re

from setuptools import find_packages, setup



def read_reqs(file: str, path: pathlib.Path) -> List[str]:
 """"""

 def readlines_ignore_comments(f):
 """"""
 return [a_ for a_ in f.readlines() if "#" not in a_ and a_]

 def recursive_flatten_ignore_str(seq: Sequence) -> Sequence:
 """"""
 if not seq: # is empty Sequence
 return seq
 if isinstance(seq[0], str):
 return seq
 if isinstance(seq[0], Sequence):
 return (
 *recursive_flatten_ignore_str(seq[0]),
 *recursive_flatten_ignore_str(seq[1:]),
 )
 return (*seq[:1], *recursive_flatten_ignore_str(seq[1:]))

 def unroll_nested_reqs(req_str: str, base_path: pathlib.Path):
 """"""
 if req_str.startswith("-r"):
 with open(base_path / req_str.strip("-r").strip()) as f:
 return [unroll_nested_reqs(req.strip(), base_path) for req in readlines_ignore_comments(f)]
 else:
 return (req_str,)

 requirements_group = []
 with open(str(path / file)) as f:
 requirements = readlines_ignore_comments(f)
 for requirement in requirements:
 requirements_group.extend(
 recursive_flatten_ignore_str(unroll_nested_reqs(requirement.strip(), path))
 )

 req_set = set(requirements_group)
 req_set.discard("")
 return list(req_set)

with open(
 pathlib.Path(__file__).parent / "projectname" / "__init__.py", "r"
) as project_init_file:
 content = project_init_file.read()
 # get version string from module
 version = re.search(r"__version__ = ['\"]([^'\"]*)['\"]", content, re.M).group(1)

 project_name = re.search(r"__project__ = ['\"]([^'\"]*)['\"]", content, re.M).group(
 1
 )
 author = re.search(r"__author__ = ['\"]([^'\"]*)['\"]", content, re.M).group(
 1
 ) # get version string from module
__author__ = author


class ProjectNamePackage:
 @property
 def test_dependencies(self) -> list:
 path = pathlib.Path(__file__).parent
 requirements_tests = []
 with open(path/'requirements' / "requirements_tests.txt") as f:
 requirements = f.readlines()

 for requirement in requirements:
 requirements_tests.append(requirement.strip())

 return requirements_tests

 @property
 def setup_dependencies(self) -> list:
 path = pathlib.Path(__file__).parent
 requirements_setup = []
 with open(path /'requirements'/ "requirements_setup.txt") as f:
 requirements = f.readlines()

 for requirement in requirements:
 requirements_setup.append(requirement.strip())

 return requirements_setup

 @property
 def package_name(self) -> str:
 return project_name

 @property
 def url(self) -> str:
 return "https://github.com/user/PythonTestPackage"

 @property
 def download_url(self) -> str:
 return self.url + "/releases"

 @property
 def readme_type(self) -> str:
 return "text/markdown"

 @property
 def packages(self):
 return find_packages(
 exclude=[
 # 'Path/To/Exclude'
 ]
 )

 @property
 def author_name(self):
 return author

 @property
 def author_email(self):
 return "name@domain.xx"

 @property
 def maintainer_name(self):
 return self.author_name

 @property
 def maintainer_email(self):
 return self.author_email

 @property
 def package_data(self):
 emds = [str(p) for p in pathlib.Path(__file__).parent.rglob(".md")]
 return {"munin_plugin_prc": [*emds]}

 @property
 def entry_points(self):
 return {
 "console_scripts": [
 # "name_of_executable = module.with:function_to_execute"
 ]
 }

 @property
 def extras(self) -> dict:
 """"""
 these_extras = {
 # 'ExtraName':['package-name; platform_system == "System(Linux,Windows)"'
 }

 path: pathlib.Path = pathlib.Path(__file__).parent / "requirements"

 for file in path.iterdir():
 if file.name.startswith("requirements_"):
 group_name_ = "_".join(file.name.strip(".txt").split("_")[1:])
 these_extras[group_name_] = read_reqs(file.name, path)

 all_dependencies = []

 for group_name in these_extras:
 all_dependencies += these_extras[group_name]
 these_extras["all"] = list(set(all_dependencies))

 return these_extras

 @property
 def requirements(self) -> list:
 requirements_out = []
 with open("requirements.txt") as f:
 requirements = f.readlines()

 for requirement in requirements:
 requirements_out.append(requirement.strip())

 return requirements_out

 @property
 def description(self):
 return "Short description"

 @property
 def readme(self):
 with open("README.md") as f:
 return f.read()

 @property
 def keyword(self):
 with open("KEYWORDS.md") as f:
 return f.read()

 @property
 def license(self):
 return "Apache License, Version 2.0"

 @property
 def classifiers(self):
 return [
 "Development Status :: 4 - Beta",
 "Environment :: Console",
 "Intended Audience :: End Users/Desktop",
 "Intended Audience :: Developers",
 "License :: OSI Approved :: Apache Software License",
 "Operating System :: MacOS :: MacOS X",
 "Operating System :: Microsoft :: Windows",
 "Operating System :: POSIX",
 "Operating System :: OS Independent",
 "Programming Language :: Python :: 3",
 "Natural Language :: English",
 # 'Topic :: Scientific/Engineering :: Artificial Intelligence'
 # 'Topic :: Software Development :: Bug Tracking',
 ]

 @property
 def version(self):
 return version


if __name__ == "__main__":

 pkg = ProjectNamePackage()

 setup(
 name=pkg.package_name,
 version=pkg.version,
 packages=pkg.packages,
 package_data=pkg.package_data,
 author=pkg.author_name,
 author_email=pkg.author_email,
 maintainer=pkg.maintainer_name,
 maintainer_email=pkg.maintainer_email,
 description=pkg.description,
 license=pkg.license,
 keywords=pkg.keyword,
 url=pkg.url,
 download_url=pkg.download_url,
 install_requires=pkg.requirements,
 extras_require=pkg.extras,
 setup_requires=pkg.setup_dependencies,
 entry_points=pkg.entry_points,
 classifiers=pkg.classifiers,
 long_description_content_type=pkg.readme_type,
 long_description=pkg.readme,
 tests_require=pkg.test_dependencies,
 include_package_data=True,
 python_requires=">=3.6",
 )