text: import codecs
  import re
  import sys
  from pathlib import Path
  from typing import Any, List, MutableMapping, Optional, Sequence, Tuple, Type
  
  import setuptools
  
  
  def _read(source_file_name: Path):
      if not source_file_name.is_file():
          raise FileNotFoundError(source_file_name)
      with codecs.open(str(source_file_name), 'r') as source_file:
          return source_file.read()
  
  
  HERE = Path().parent.absolute()
  PACKAGE_PATH = HERE / 'monocat'
  
  LONG_DESCRIPTION = _read(HERE / 'README.md')
  METADATA = {
      'name': 'monocat',
      'author': 'Jeffrey Wilges',
      'author_email': 'jeffrey@wilges.com',
      'description': 'monocat is a command line utility for managing GitHub releases',
      'url': 'https://github.com/jwilges/monocat',
      'license': 'BSD'
  }
  METADATA_TEMPLATE = '\n'.join((
      "VERSION = '{version}'",
      *(
          f"{key.upper()} = '{value.replace('{', '{{').replace('}', '}}')}'"
          for key, value in METADATA.items()
      ),
      '' # final newline
  ))
  
  OPTIONAL_COMMAND_CLASSES: MutableMapping[str, Type] = {}
  OPTIONAL_COMMAND_OPTIONS: MutableMapping[str, MutableMapping[str, Sequence[str]]] = {}
  
  try:
      from sphinx.setup_command import BuildDoc
      OPTIONAL_COMMAND_CLASSES['build_sphinx'] = BuildDoc
      OPTIONAL_COMMAND_OPTIONS['build_sphinx'] = {
          'source_dir': ('setup.py', 'docs'),
          'build_dir': ('setup.py', 'docs/_build')
      }
  except ImportError:
      pass
  
  
  class ValidateTagCommand(setuptools.Command):
      """A validator that ensures the package version both is in the canonical form per
      PEP-440 and matches the current git tag"""
      description = 'validate that the package version matches the current git tag'
      user_options: List[Tuple[str, Optional[str], str]] = [
          ('output-azure-variables', None, 'Output Azure Pipeline version variables'),
      ]
  
      VERSION_PATTERN = r'''
          v?
          (?:
              (?:(?P<epoch>[0-9]+)!)?                           # epoch
              (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
              (?P<pre>                                          # pre-release
                  [-_\.]?
                  (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
                  [-_\.]?
                  (?P<pre_n>[0-9]+)?
              )?
              (?P<post>                                         # post release
                  (?:-(?P<post_n1>[0-9]+))
                  |
                  (?:
                      [-_\.]?
                      (?P<post_l>post|rev|r)
                      [-_\.]?
                      (?P<post_n2>[0-9]+)?
                  )
              )?
              (?P<dev>                                          # dev release
                  [-_\.]?
                  (?P<dev_l>dev)
                  [-_\.]?
                  (?P<dev_n>[0-9]+)?
              )?
          )
          (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
      '''
      VERSION_FORMAT = re.compile(
          r'^\s*' + VERSION_PATTERN + r'\s*$',
          re.VERBOSE | re.IGNORECASE,
      )
  
      def initialize_options(self):
          self.output_azure_variables = False
  
      def finalize_options(self):
          pass
  
      def run(self):
          """Warn and exit if the package version either:
              a) is not in the canonical format per PEP-440 or,
              b) does not match any HEAD git tag version."""
          import setuptools_scm
          version = setuptools_scm.get_version(relative_to=Path(__file__))
  
          if self.output_azure_variables:
              print(f'##vso[task.setvariable variable=is_prerelease;isOutput=true;]{self.is_prerelease(version)!s}')
  
          if not self.is_canonical(version):
              self.warn(f'package version ({version}) is not in the canonical format per PEP-440')
              sys.exit(1)
  
      @classmethod
      def is_prerelease(cls, version: str) -> bool:
          version_match = cls.VERSION_FORMAT.match(version)
          return (
              version_match is None or
              any(
                  value for key, value in version_match.groupdict().items()
                  if key in ('pre', 'dev', 'local')
              )
          )
  
      @staticmethod
      def is_canonical(version: str) -> bool:
          """Return true if `version` is canonical per PEP-440."""
          return re.match(r'^([1-9][0-9]*!)?(0|[1-9][0-9]*)(\.(0|[1-9][0-9]*))*((a|b|rc)(0|[1-9][0-9]*))?(\.post(0|[1-9][0-9]*))?(\.dev(0|[1-9][0-9]*))?$', version) is not None
  
  
  setuptools.setup(
      **METADATA,
      long_description=LONG_DESCRIPTION,
      long_description_content_type='text/markdown',
      packages=setuptools.find_packages(exclude=['tests*']),
      entry_points={
          'console_scripts': ['monocat=monocat.cli:main'],
      },
      use_scm_version={
          'relative_to': Path(__file__),
          'write_to': PACKAGE_PATH / '__metadata__.py',
          'write_to_template': METADATA_TEMPLATE,
      },
      setup_requires=['setuptools_scm'],
      python_requires='>=3.6',
      install_requires=[
          'pydantic>=1.4',
          'uritemplate>=3',
          'urllib3',
          'dataclasses; python_version < "3.7"'
      ],
      classifiers=[
          'Development Status :: 4 - Beta',
          'Environment :: Console',
          'Operating System :: POSIX :: Linux',
          'Operating System :: MacOS :: MacOS X',
          'Operating System :: Microsoft :: Windows',
          'Programming Language :: Python :: 3.6',
          'Programming Language :: Python :: 3.7',
          'Programming Language :: Python :: 3.8',
          'Topic :: Software Development :: Build Tools',
          'Topic :: System :: Distributed Computing',
          'Topic :: System :: Networking',
          'Topic :: System :: Software Distribution',
          'Topic :: Utilities'
      ],
      cmdclass={
          'validate_tag': ValidateTagCommand,
          **OPTIONAL_COMMAND_CLASSES
      },
      command_options={
          **OPTIONAL_COMMAND_OPTIONS
      },
  )
  