text: #!/usr/bin/env python
  
  import os
  import re
  
  
  from setuptools import setup
  
  fname = os.path.join(os.path.dirname(__file__), "README.rst")
  
  if os.path.exists(fname):
      ld = open(fname).read()
  else:
      ld = "Django pyfilesystem integration"
  
  
  def is_requirement(line):
      """
      Return True if the requirement line is a package requirement.
  
      Returns:
          bool: True if the line is not blank, a comment,
          a URL, or an included file
      """
      # UPDATED VIA SEMGREP - if you need to remove/modify this method remove this line and add a comment specifying why
  
      return line and line.strip() and not line.startswith(('-r', '#', '-e', 'git+', '-c'))
  
  
  def load_requirements(*requirements_paths):
      """
      Load all requirements from the specified requirements files.
  
      Requirements will include any constraints from files specified
      with -c in the requirements files.
      Returns a list of requirement strings.
      """
      # UPDATED VIA SEMGREP - if you need to remove/modify this method remove this line and add a comment specifying why.
  
      requirements = {}
      constraint_files = set()
  
      # groups "my-package-name<=x.y.z,..." into ("my-package-name", "<=x.y.z,...")
      requirement_line_regex = re.compile(r"([a-zA-Z0-9-_.]+)([<>=][^#\s]+)?")
  
      def add_version_constraint_or_raise(current_line, current_requirements, add_if_not_present):
          regex_match = requirement_line_regex.match(current_line)
          if regex_match:
              package = regex_match.group(1)
              version_constraints = regex_match.group(2)
              existing_version_constraints = current_requirements.get(package, None)
              # it's fine to add constraints to an unconstrained package, but raise an error if there are already
              # constraints in place
              if existing_version_constraints and existing_version_constraints != version_constraints:
                  raise BaseException(f'Multiple constraint definitions found for {package}:'
                                      f' "{existing_version_constraints}" and "{version_constraints}".'
                                      f'Combine constraints into one location with {package}'
                                      f'{existing_version_constraints},{version_constraints}.')
              if add_if_not_present or package in current_requirements:
                  current_requirements[package] = version_constraints
  
      # process .in files and store the path to any constraint files that are pulled in
      for path in requirements_paths:
          with open(path) as reqs:
              for line in reqs:
                  if is_requirement(line):
                      add_version_constraint_or_raise(line, requirements, True)
                  if line and line.startswith('-c') and not line.startswith('-c http'):
                      constraint_files.add(os.path.dirname(path) + '/' + line.split('#')[0].replace('-c', '').strip())
  
      # process constraint files and add any new constraints found to existing requirements
      for constraint_file in constraint_files:
          with open(constraint_file) as reader:
              for line in reader:
                  if is_requirement(line):
                      add_version_constraint_or_raise(line, requirements, False)
  
      # process back into list of pkg><=constraints strings
      constrained_requirements = [f'{pkg}{version or ""}' for (pkg, version) in sorted(requirements.items())]
      return constrained_requirements
  
  
  def get_version(*file_paths):
      """
      Extract the version string from the file at the given relative path fragments.
      """
      filename = os.path.join(os.path.dirname(__file__), *file_paths)
      with open(filename, encoding='utf-8') as opened_file:
          version_file = opened_file.read()
          version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]",
                                    version_file, re.M)
      if version_match:
          return version_match.group(1)
      raise RuntimeError('Unable to find version string.')
  
  
  VERSION = get_version("djpyfs", "__init__.py")
  
  
  setup(
      name='django-pyfs',
      version=VERSION,
      description='Django pyfilesystem integration',
      author='Piotr Mitros',
      author_email='pmitros@edx.org',
      packages=['djpyfs'],
      license="Apache 2.0",
      url="https://github.com/edx/django-pyfs",
      long_description=ld,
      long_description_content_type='text/x-rst',
      classifiers=[
          "Development Status :: 4 - Beta",
          "Framework :: Django",
          'Framework :: Django :: 3.2',
          'Framework :: Django :: 4.0',
          "Programming Language :: Python",
          "Programming Language :: Python :: 3",
          "Programming Language :: Python :: 3.8",
          "Topic :: Software Development :: Libraries :: Python Modules",
          "License :: OSI Approved :: Apache Software License",
      ],
      install_requires=load_requirements('requirements/base.in'),
      tests_require=load_requirements('requirements/test.in'),
  )
  