text: #!/usr/bin/env python
  # -*- coding: utf8 -*-
  
  # python setup.py build_ext --inplace
  
  """
  setup.py file
  """
  import multiprocessing
  import os
  import pathlib
  import platform
  import re
  import shutil
  import subprocess
  import sys
  import sysconfig
  import time
  import unittest
  import warnings
  
  from abc import ABC
  
  import distutils
  from distutils import sysconfig
  from distutils.version import LooseVersion
  from distutils.command.build import build
  from distutils.command.clean import clean
  
  from setuptools import find_packages, setup, Command
  from setuptools.command.install import install
  from setuptools.extension import Extension
  
  force_blas = False
  if "--force-blas" in sys.argv:
      force_blas = True
      sys.argv.remove("--force-blas")
  
  # Available debug flags
  #
  #   DEBUG_C_ARRAY       : count #allocations of C-arrays
  #   DEBUG_ARRAY         : Track creation/destruction of Array objects
  #   DEBUG_SHAREDARRAY   : Track creation/destruction of SharedArray objects
  #   DEBUG_VARRAY        : Track VArray
  #   DEBUG_COSTLY_THROW  : Enables some costly tests to throw error
  #                         (such as Array[i] if i not in range)
  #   DEBUG_VERBOSE       : Error messages from CPP extensions will include
  #                         backtrace and error loc
  
  # debug_flags = ['DEBUG_C_ARRAY', 'DEBUG_ARRAY', 'DEBUG_COSTLY_THROW',
  #                'DEBUG_SHAREDARRAY', 'DEBUG_VARRAY', 'DEBUG_VERBOSE']
  
  TICK_DEBUG=1
  # allow disable debug
  if os.environ.get('TICK_DEBUG') is not None:
      TICK_DEBUG=os.environ['TICK_DEBUG']
  
  TICK_WERROR=1
  # allow disable Werror
  if os.environ.get('TICK_WERROR') is not None:
      TICK_WERROR=os.environ['TICK_WERROR']
  
  debug_flags = []
  
  if TICK_DEBUG == 1 or TICK_DEBUG == "1":
      debug_flags = ['DEBUG_COSTLY_THROW']
  
  TICK_CMAKE_GENERATOR=None
  if os.environ.get('TICK_CMAKE_GENERATOR') is not None:
      TICK_CMAKE_GENERATOR=os.environ['TICK_CMAKE_GENERATOR']
  
  # If true, add compilation flags to use fast (but maybe inaccurate) math
  # See https://gcc.gnu.org/wiki/FloatingPointMath
  use_fast_math = True
  
  version_info = sys.version_info
  
  python_min_ver = (3, 6, 0)
  python_ver = (version_info.major, version_info.minor, version_info.micro)
  
  if python_ver < python_min_ver:
      txt = 'Python version {0}.{1}.{2} ' \
            'lower than the required version >= {3}.{4}.{5}.'
  
      warnings.warn(txt.format(*(python_ver + python_min_ver)))
  
  # The next block ensures that we build a link-time linkable dynamic library for
  # OSX builds instead of a bundle.
  #
  # Snippet from http://stackoverflow.com/a/32765319/2299947
  if sys.platform == 'darwin':
      vars = sysconfig.get_config_vars()
      vars['LDSHARED'] = vars['LDSHARED'].replace('-bundle', '-dynamiclib')
  
  # If we're installing via a wheel or not
  is_building_tick = any(arg in ("build",
                                 "build_ext",
                                 "bdist",
                                 "bdist_wheel",
                                 "develop",) for arg in sys.argv)
  
  # Obtain the numpy include directory.
  # This logic works across numpy versions.
  numpy_available = False
  numpy_include = ""
  blas_info = {}
  try:
      import numpy as np
      from numpy.distutils.system_info import get_info
  
      try:
          numpy_include = np.get_include()
      except AttributeError:
          numpy_include = np.get_numpy_include()
  
      # Determine if we have an available BLAS implementation
      if force_blas: # activated with build --force-blas
          blas_info = get_info("blas_opt", 0)
      elif platform.system() == 'Windows':
          try:
              with open(os.devnull, 'w') as devnull:
                  exitCode = subprocess.check_output(
                      "python tools/python/blas/check_cblas.py build_ext",
                      stderr=devnull,
                      shell=True)
                  blas_info = get_info("blas_opt", 0)
          except subprocess.CalledProcessError as subError:
              print("Error executing check_cblas.py - cblas not found")
      else:
          try:
              with open(os.devnull, 'w') as devnull:
                  exitCode = subprocess.check_output(
                      "python tools/python/blas/check_mkl.py build_ext",
                      stderr=devnull,
                      shell=True)
                  blas_info = get_info("blas_opt", 0)
          except subprocess.CalledProcessError as subError:
              print("Error executing check_mkl.py - mkl not found")
  
      numpy_available = True
  except ImportError as e:
      if is_building_tick:
          print(e)
          warnings.warn("numpy is not installed:\n"
                        " - Include directory for numpy integration may not be "
                        "correct\n "
                        " - BLAS will not be used for this build\n")
  
  # sometimes disabling blas is desired
  if os.environ.get('TICK_NO_OPTS') is not None:
      if os.environ['TICK_NO_OPTS'] == '1':
          blas_info = {}
  
  # By default, we assume that scipy uses 32 bit integers for indices in sparse
  # arrays
  sparse_indices_flag = "-DTICK_SPARSE_INDICES_INT32"
  try:
      import numpy as np
      from scipy.sparse import sputils
  
      sparsearray_type = sputils.get_index_dtype()
  
      if sparsearray_type == np.int64:
          sparse_indices_flag = "-DTICK_SPARSE_INDICES_INT64"
  except ImportError as e:
      if is_building_tick and numpy_available:
          print(e)
          warnings.warn("scipy is not installed, unable to determine "
                        "sparse array integer type (assuming 32 bits)\n")
  
  if os.name == 'posix':
      if platform.system() == 'Darwin':
          os_version = platform.mac_ver()[0]
          # keep only major + minor
          os_version = '.'.join(os_version.split('.')[:2])
  
          if LooseVersion(os_version) < LooseVersion('10.9'):
              raise ValueError(
                  'You need to have at least mac os 10.9 to build this package')
  
          # We set this variable manually because anaconda set it to a deprecated
          # one
          os.environ['MACOSX_DEPLOYMENT_TARGET'] = os_version
  
  # check for debug pyenv - PYVER must be exported as env var. Debug pyenv setup:
  #    PYENV=3.7.0
  #    CFLAGS="-O0 -ggdb" CONFIGURE_OPTS="--enable-shared" pyenv install -kg $PYVER
  #    PYENV=${PYENV}-debug
  #    eval "$(pyenv init -)"
  #    pyenv global ${PYVER}
  #    pyenv local ${PYVER}
  
  PYVER = ""
  PYVER_DBG = ""
  if os.environ.get('PYVER') is not None:
      PYVER = os.environ['PYVER']
      if PYVER.endswith("-debug"):
          PYVER_DBG = "-pydebug"
  
  # Directory containing built .so files before they are moved either
  # in source (with build flag --inplace) or to site-packages (by install)
  # E.g. build/lib.macosx-10.11-x86_64-3.5
  build_dir = "build/lib.{}-{}"+PYVER_DBG
  build_dir = build_dir.format(distutils.util.get_platform(),
                                       sys.version[0:3])
  
  class SwigExtension(Extension):
      """This only adds information about extension construction, useful for
      library sharing
      """
  
      def __init__(self, *args, module_ref=None, ext_name=None, **kwargs):
          super().__init__(*args, **kwargs)
          self.module_ref = module_ref
          self.ext_name = ext_name
  
  class SwigPath:
      """Small class to handle module creation and check project structure
      """
  
      def __init__(self, module_path, extension_name):
          module_path = os.path.normpath(module_path)
  
  
          # Module C++ source directory (e.g. lib/cpp/tick/base)
          self.src = os.path.join(module_path, 'src')
  
          # Module SWIG interface files directory (e.g. tick/array/swig)
          self.swig = "lib/swig/" + module_path[5:]
  
          # Module build directory. Will contain generated .py files, and .so
          # files if built with flag --inplace.
          #
          # E.g. tick/array/build
          self.build = os.path.join(module_path, 'build')
  
          self.extension_name = extension_name
          self.private_extension_name = '_' + extension_name
  
          # Transform folder path to module path
          self.extension_path = self.build \
                                    .replace('.', '') \
                                    .replace('/', '.') \
                                + '.' + self.private_extension_name
  
          # Filename of the produced .so file (e.g. _array.so)
          self.lib_filename = '{}{}'.format(self.private_extension_name,
                                            sysconfig.get_config_var('EXT_SUFFIX'))
  
  
  def create_extension(extension_name, module_dir,
                       cpp_files, h_files, swig_files, folders=[],
                       include_modules=None, extra_compile_args=None,
                       swig_opts=None):
      swig_path = SwigPath(module_dir, extension_name)
      extension_path = swig_path.extension_path
  
      # Add directory to filenames
      def add_dir_name(dir_name, filenames):
          return list(os.path.join(dir_name, filename) for filename in filenames)
  
      swig_files = add_dir_name("lib/swig/tick/" + module_dir[7:], swig_files)
  
      for folder in folders:
          for file in os.listdir(folder):
              file_path = os.path.join(folder, file)
              if os.path.isfile(file_path):
                  _, ext = os.path.splitext(file)
                  if ext == '.cpp':
                      cpp_files += [os.path.join(folder, file)]
                  elif ext == ".txt":
                      pass
                  elif ext == ".inl":
                      pass
                  else:
                      warnings.warn('Included file %s in folder %s has an '
                                    'unknown extension "%s"' % (file,
                                                                folder,
                                                                ext))
  
      min_swig_opts = ['-py3',
                       '-c++',
                       '-Ilib/swig',
                       '-Ilib/include',
                       '-outdir', swig_path.build,
                       ]
  
      if swig_opts is None:
          swig_opts = min_swig_opts
      else:
          swig_opts.extend(min_swig_opts)
  
      # Here we set the minimum compile flags.
      min_extra_compile_args = ["-D_FILE_OFFSET_BITS=64",
                                "-DPYTHON_LINK",
                                "-DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION",
                                '-Ilib/include',
                                sparse_indices_flag,
                                '-std=c++11',
                                '-O2', # -O3 is sometimes dangerous and has caused segfaults on Travis
                                '-DNDEBUG', # some assertions fail without this (TODO tbh)
                                ]
      if TICK_DEBUG == 0 or TICK_DEBUG == "0":
          min_extra_compile_args.append("-g0")
  
      if use_fast_math:
          min_extra_compile_args.append('-ffast-math')
  
      if extra_compile_args is None:
          extra_compile_args = min_extra_compile_args
      else:
          extra_compile_args.extend(min_extra_compile_args)
  
      extra_compile_args.append("-Wall")
  
      if platform.system() == 'Windows':
          extra_compile_args.append("-DBUILDING_DLL")
      elif TICK_WERROR == 1 or TICK_WERROR == "1":
          ## Added -Wall to get all warnings and -Werror to treat them as errors
          extra_compile_args.append("-Werror")
  
      # Include directory of module
      mod = SwigPath(module_dir, extension_name)
  
      libraries = []
      library_dirs = []
      runtime_library_dirs = []
      extra_link_args = []
      define_macros = []
      extra_include_dirs = ["include", "swig"]
  
      # Deal with (optional) BLAS
      extra_compile_args.extend(blas_info.get("extra_compile_args", []))
      extra_link_args.extend(blas_info.get("extra_link_args", []))
      libraries.extend(blas_info.get("libraries", []))
      library_dirs.extend(blas_info.get("library_dirs", []))
      define_macros.extend(blas_info.get("define_macros", []))
  
      if 'define_macros' in blas_info and \
              any(key == 'HAVE_CBLAS' for key, _ in blas_info['define_macros']):
          define_macros.append(('TICK_USE_CBLAS', None))
      if "libraries" in blas_info and "mkl_rt" in blas_info["libraries"]:
          define_macros.append(('TICK_USE_MKL', None))
          extra_include_dirs.extend(blas_info["include_dirs"])
          if platform.system() != 'Windows':
              for lib_dir in blas_info["library_dirs"]:
                  extra_link_args.append(
                      "-Wl,-rpath,"+ lib_dir
                  )
              # if not Linux assume MacOS
              if platform.system() != 'Linux':
                  rel_path = os.path.relpath(lib_dir, swig_path.build)
                  if os.path.exists(rel_path):
                      extra_link_args.append("-Wl,-rpath,@loader_path/"+ rel_path)
  
      if include_modules is None:
          include_modules = []
  
      # Include all what need for module link
      for mod in include_modules:
          if mod.__class__ != SwigPath:
              raise ValueError("Unhandled class for included module")
  
          for opts in [swig_opts, extra_compile_args]:
              opts.extend(["-I" + mod.swig])
  
          # Because setuptools produces shared object files with non-standard
          # On windows we need to use ".lib" rather than ".pyd"
          # when linking libs to other libs
          if platform.system() == 'Windows':
              lib = os.path.join(build_dir, mod.build, "_"+mod.extension_name)
              lib += os.path.splitext(sysconfig.get_config_var("EXT_SUFFIX"))[0]
              libraries.append(lib)
          elif platform.system() == 'Linux':
              lib_dir = os.path.abspath(os.path.join(build_dir, mod.build))
              extra_link_args.append("-L"+lib_dir)
              extra_link_args.append("-Wl,-rpath,"+lib_dir)
              extra_link_args.append("-l:"+mod.lib_filename)
          else:
              extra_link_args.append(os.path.abspath(
                  os.path.join(build_dir, mod.build, mod.lib_filename)))
  
          # Make sure that the runtime linker can find shared object
          # dependencies by using the relative path to the dependency library.
          rel_path = os.path.relpath(mod.build, swig_path.build)
          if platform.system() == 'Linux':
              # $ORIGIN refers to the location of the current shared object file
              # at runtime
              runtime_library_dirs.append("\$ORIGIN/%s" % rel_path)
          elif platform.system() == 'Windows':
              pass
          else:  # Assuming non-Windows builds for now
              # For OSX builds we use @loader_path instead
              extra_link_args.append(
                  "-Wl,-rpath,%s" % '@loader_path/%s' % rel_path
              )
  
      # Setting the SONAME/install_name for the built libraries. It ensures that
      # the runtime linker will have a chance to find the libraries even after
      # they're moved (during install, for example)
      filename = swig_path.lib_filename
      if platform.system() == 'Linux':
          extra_link_args.append('-Wl,-soname,%s' % filename)
      elif platform.system() == 'Windows':
          pass
      else:
          # For OSX the install_name needs to be prefixed with @rpath
          extra_link_args.append('-Wl,-install_name,@rpath/%s' % filename)
  
      for df in debug_flags:
          full_flag = "-D" + df
  
          extra_compile_args.append(full_flag)
  
          if df == 'DEBUG_COSTLY_THROW':
              swig_opts.append(full_flag)
  
      # Adding Cereal serialization library
      extra_include_dirs.append("lib/third_party/cereal/include")
  
      # Adding numpy include directory
      if numpy_include:
          extra_include_dirs.append(numpy_include)
  
      # This is to override the use of IMPLIB in distutils
      # which puts the lib/exp files in the wrong directory
      # see: https://github.com/python/cpython/blob/08bb8a41cc976343795bd0e241cd7388e9f44ad5/Lib/distutils/_msvccompiler.py#L467
      if platform.system() == 'Windows':
          implib = "/IMPLIB:" + os.path.abspath(
              os.path.join(build_dir, swig_path.build, "_"+extension_name))
          implib += os.path.splitext(sysconfig.get_config_var("EXT_SUFFIX"))[0]
          extra_link_args.append(implib + ".lib")
  
      core_module = SwigExtension(extension_path, module_ref=swig_path,
                                  sources=swig_files + cpp_files,
                                  extra_compile_args=extra_compile_args,
                                  extra_link_args=extra_link_args,
                                  define_macros=define_macros,
                                  swig_opts=swig_opts,
                                  libraries=libraries,
                                  include_dirs=extra_include_dirs,
                                  library_dirs=library_dirs,
                                  runtime_library_dirs=runtime_library_dirs,
                                  depends=h_files,
                                  language="c++",
                                  ext_name=extension_name)
  
      return core_module
  
  
  ##############################
  # Create extensions
  ##############################
  
  array_extension_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/array"
      ],
      "swig_files": ["array_module.i"],
      "module_dir": "./tick/array/",
      "extension_name": "array"
  }
  
  array_extension = create_extension(**array_extension_info)
  
  base_extension_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/base",
          "lib/cpp/base/math"
      ],
      "swig_files": ["base_module.i"],
      "module_dir": "./tick/base",
      "extension_name": "base",
      "include_modules": [array_extension.module_ref]
  }
  
  base_extension = create_extension(**base_extension_info)
  
  base_array_modules = [array_extension.module_ref, base_extension.module_ref]
  
  array_test_extension_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": ["lib/cpp/array_test"],
      "swig_files": ["array_test_module.i"],
      "module_dir": "./tick/array_test/",
      "extension_name": "array_test",
      "include_modules": base_array_modules,
  }
  
  test_extension = create_extension(**array_test_extension_info)
  
  random_extension_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": ["lib/cpp/random"],
      "swig_files": ["crandom_module.i"],
      "module_dir": "./tick/random/",
      "extension_name": "crandom",
      "include_modules": base_array_modules
  }
  
  random_extension = create_extension(**random_extension_info)
  
  base_model_core_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/base_model"
      ],
      "swig_files": ["base_model_module.i"],
      "module_dir": "./tick/base_model/",
      "extension_name": "base_model",
      "include_modules": base_array_modules
  }
  base_model_core = create_extension(**base_model_core_info)
  
  linear_model_core_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/linear_model"
      ],
      "swig_files": ["linear_model_module.i"],
      "module_dir": "./tick/linear_model/",
      "extension_name": "linear_model",
      "include_modules": base_array_modules +
      [
        base_model_core.module_ref,
      ]
  }
  linear_model_core = create_extension(**linear_model_core_info)
  
  hawkes_simulation_extension_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/hawkes/simulation",
          "lib/cpp/hawkes/simulation/hawkes_baselines",
          "lib/cpp/hawkes/simulation/hawkes_kernels"
      ],
      "swig_files": [
        "hawkes_simulation_module.i"
      ],
      "module_dir": "./tick/hawkes/simulation/",
      "extension_name": "hawkes_simulation",
      "include_modules": base_array_modules + [random_extension.module_ref]
  }
  hawkes_simulation_extension = \
      create_extension(**hawkes_simulation_extension_info)
  
  hawkes_model_extension_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/hawkes/model",
          "lib/cpp/hawkes/model/base",
          "lib/cpp/hawkes/model/list_of_realizations",
      ],
      "swig_files": [
        "hawkes_model_module.i"
      ],
      "module_dir": "./tick/hawkes/model/",
      "extension_name": "hawkes_model",
      "include_modules": base_array_modules + [base_model_core.module_ref]
  }
  hawkes_model_extension = create_extension(**hawkes_model_extension_info)
  
  hawkes_inference_extension_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/hawkes/inference",
      ],
      "swig_files": [
        "hawkes_inference_module.i"
      ],
      "module_dir": "./tick/hawkes/inference/",
      "extension_name": "hawkes_inference",
      "include_modules": base_array_modules +
      [
          base_model_core.module_ref,
          hawkes_model_extension.module_ref,
      ]
  }
  hawkes_inference_extension = create_extension(**hawkes_inference_extension_info)
  
  prox_core_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/prox"
      ],
      "swig_files": ["prox_module.i"],
      "module_dir": "./tick/prox/",
      "extension_name": "prox",
      "include_modules": base_array_modules
  }
  prox_core = create_extension(**prox_core_info)
  
  robust_extension_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/robust"
      ],
      "swig_files": ["robust_module.i"],
      "module_dir": "./tick/robust/",
      "extension_name": "robust",
      "include_modules": base_array_modules + [
        base_model_core.module_ref,linear_model_core.module_ref]
  }
  robust_extension = create_extension(**robust_extension_info)
  
  solver_core_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/solver"
      ],
      "swig_files": ["solver_module.i"],
      "module_dir": "./tick/solver/",
      "extension_name": "solver",
      "include_modules": base_array_modules + [random_extension.module_ref,
                                               base_model_core.module_ref,
                                               linear_model_core.module_ref,
                                               prox_core.module_ref,
                                               robust_extension.module_ref]
  }
  solver_core = create_extension(**solver_core_info)
  
  preprocessing_core_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/preprocessing"
      ],
      "swig_files": ["preprocessing_module.i"],
      "module_dir": "./tick/preprocessing/",
      "extension_name": "preprocessing",
      "include_modules": base_array_modules
  }
  
  preprocessing_core = create_extension(**preprocessing_core_info)
  
  survival_extension_info = {
      "cpp_files": [],
      "h_files": [],
      "folders": [
          "lib/cpp/survival"
      ],
      "swig_files": ["survival_module.i"],
      "module_dir": "./tick/survival/",
      "extension_name": "survival",
      "include_modules": base_array_modules + [base_model_core.module_ref]
  }
  survival_extension = create_extension(**survival_extension_info)
  
  tick_modules = [
      array_extension, base_extension, test_extension,
      random_extension, base_model_core, linear_model_core,
      hawkes_simulation_extension, hawkes_model_extension,
      hawkes_inference_extension,
      prox_core, preprocessing_core,
      robust_extension, survival_extension, solver_core
  ]
  
  # Abstract class for tick-specific commands that need access to common build
  # directories
  class TickCommand(Command, ABC):
      tick_dir = os.path.abspath(os.path.join(os.curdir, 'tick'))
      cpp_build_dir = os.path.abspath(os.path.join(build_dir, 'cpptest'))
  
      user_options = []
  
      def initialize_options(self):
          """Set default values for options."""
          pass
  
      def finalize_options(self):
          """Post-process options."""
          pass
  
  
  class TickBuild(build):
      swig_min_ver = (4, 0, 0)
  
      @staticmethod
      def extract_swig_version(swig_ver_str):
          m = re.search('SWIG Version (\d+).(\d+).(\d+)', swig_ver_str)
  
          if not m:
              txt = 'Could not extract SWIG version from string: {0}'
  
              warnings.warn(txt.format(swig_ver_str))
  
              return 0, 0, 0
  
          return tuple(int(x) for x in m.groups()[0:3])
  
      def run(self):
          swig_ver = self.extract_swig_version(
              str(subprocess.check_output(['swig', '-version'])))
  
          if swig_ver < self.swig_min_ver:
              txt = 'SWIG version {0}.{1}.{2} ' \
                    'lower than the required version >= {3}.{4}.{5}. ' \
                    'This will likely cause build errors!'
  
              warnings.warn(txt.format(*(swig_ver + self.swig_min_ver)))
  
          self.run_command('build_ext')
          build.run(self)
  
  
  class TickInstall(install):
      def run(self):
          self.run_command('build_ext')
          install.run(self)
  
  
  class BuildRunCPPTests(TickCommand):
      description = 'build and run tick C++ tests'
  
      def run(self):
          self.run_command('makecpptest')
          self.run_command('runcpptest')
  
  
  class RunCPPTests(TickCommand):
      description = 'run tick C++ tests'
  
      def run(self):
          make_cmd = ['make', 'check']
          subprocess.check_call(make_cmd, cwd=self.cpp_build_dir)
  
  
  class BuildCPPTests(TickCommand):
      build_jobs = 1
      description = 'build tick C++ tests'
      user_options = [
          ('build-jobs=', 'j',
           'number of parallel build jobs (default is number of available CPU '
           'cores reported by Python)'),
      ]
  
      def initialize_options(self):
          """Set default values for options."""
          self.build_jobs = multiprocessing.cpu_count()
  
      def run(self):
          relpath = os.path.relpath(self.tick_dir, self.cpp_build_dir)
          cmake_exe = os.environ.get('TICK_CMAKE', 'cmake')
  
          inc_dir = sysconfig.get_python_inc()
          cmake_cmd = [cmake_exe,
                       '-DPYTHON_INCLUDE_DIR={}'.format(inc_dir),
                       '-DTICK_REBUILD_LIBS=OFF',
                       '-DBENCHMARK=OFF',
                       relpath + '/../lib']
  
          if TICK_CMAKE_GENERATOR is not None:
              cmake_cmd.extend(['-G', '{}'.format(TICK_CMAKE_GENERATOR)])
  
          # Feed the path to the built C++ extensions so CMake does not have to
          # build them again
          for mod in tick_modules:
              full_path = os.path.abspath(
                  os.path.join(mod.module_ref.build, mod.module_ref.lib_filename))
  
              cmake_cmd.append(
                  '-DTICK_LIB_{}={}'.format(mod.ext_name.upper(), full_path))
  
          define_macros = []
          if 'define_macros' in blas_info and \
                  any(key == 'HAVE_CBLAS' for key, _ in blas_info['define_macros']):
              cmake_cmd.append('-DUSE_BLAS=ON')
  
          os.makedirs(os.path.join(self.cpp_build_dir, 'cpptest'), exist_ok=True)
          subprocess.check_call(cmake_cmd, cwd=self.cpp_build_dir)
  
          make_cmd = ['make', 'VERBOSE=1', 'all', '-j{}'.format(self.build_jobs)]
          subprocess.check_call(make_cmd, cwd=self.cpp_build_dir)
  
  
  class RunCPPLint(TickCommand):
      description = 'run cpplint on tick C++ source files'
  
      CPPLINT_DIRS = [
          'lib/include',
          'lib/cpp',
      ]
  
      def run(self):
          try:
              import cpplint as cl
  
              cl_state = cl._cpplint_state
              error_count = 0
  
              for dir in self.CPPLINT_DIRS:
                  print("Processing {}".format(dir))
  
                  cl_state.ResetErrorCounts()
                  filenames = list(pathlib.Path(dir).glob('**/*.h')) + \
                              list(pathlib.Path(dir).glob('**/*.cpp'))
  
                  for filename in filenames:
                      cl.ProcessFile(str(filename), cl_state.verbose_level)
                  cl_state.PrintErrorCounts()
  
                  error_count += cl_state.error_count
                  print('')
  
              if error_count > 0:
                  raise RuntimeError("Codestyle check by cpplint failed")
  
          except ImportError:
              warnings.warn("Stylecheck by cpplint failed because cpplint "
                            "is not installed as a Python module")
  
  
  class RunPyLint(TickCommand):
      # We need to define if and how we run pylint
  
      description = 'run tick PyLint codestyle check'
      start_dir = '.'
  
      @staticmethod
      def run():
          raise NotImplementedError('Running pylint from setup.py'
                                    'not supported yet')
  
  class RunPyTests(TickCommand):
      description = 'run tick Python tests'
      start_dir = '.'
  
      user_options = [
          ('start-dir=', 's',
           'directory to start looking for Python tests (e.g. tick/simulation)'),
      ]
  
      def initialize_options(self):
          """Set default values for options."""
          self.start_dir = '.'
  
      def run(self):
          if platform.system() == 'Windows':
              print("The pytest command has issues with threads on Windows")
              print('Instead please run:')
              print('python3 -m unittest discover -v . "*_test.py"')
              exit(1)
          loader = unittest.TestLoader()
          alltests = loader.discover(self.start_dir, pattern="*_test.py")
          result = unittest.TextTestRunner(verbosity=2).run(alltests)
          sys.exit(not result.wasSuccessful())
  
  
  class RunTestSuites(TickCommand):
      description = 'run tick Python and C++ tests'
  
      def run(self):
          self.run_command('cpptest')
          self.run_command('pytest')
  
  
  class CleanTick(clean):
      description = 'cleans all generated and built files'
  
      def run(self):
          seconds_until_clean = 5
  
          print("Cleaning source directories in %d seconds..." %
                seconds_until_clean)
  
          time.sleep(seconds_until_clean)
  
          clean.run(self)
  
          shutil.rmtree(build_dir, ignore_errors=True)
  
          patterns = [
              '**/*.so',
              '**/*_wrap.cpp',
              '**/__pycache__/*.pyc',
              '**/__pycache__',
          ]
  
          for paths in (pathlib.Path(os.curdir).glob(p) for p in patterns):
              for path in paths:
                  print("Deleting {}".format(path))
  
                  if path.is_dir():
                      path.rmdir()
                  else:
                      path.unlink()
  
  
  setup(name="tick",
        version='0.7.0.1',
        author="Emmanuel Bacry, "
               "Stephane Gaiffas, "
               "Martin Bompaire, "
               "Søren V. Poulsen, "
               "Maryan Morel, "
               "Simon Bussy, "
               "Philip Deegan",
        author_email='martin.bompaire@polytechnique.edu, '
                     'philip.deegan@polytechnique.edu',
        url="https://x-datainitiative.github.io/tick/",
        description="Module for statistical learning, with a particular emphasis "
                    "on time-dependent modelling",
        ext_modules=tick_modules,
        install_requires=['numpy',
                          'scipy',
                          'numpydoc',
                          'matplotlib',
                          'sphinx',
                          'pandas',
                          'dill',
                          'scikit-learn'],
        packages=find_packages(),
        cmdclass={'build': TickBuild,
                  'install': TickInstall,
                  'makecpptest': BuildCPPTests,
                  'runcpptest': RunCPPTests,
                  'cpptest': BuildRunCPPTests,
                  'cpplint': RunCPPLint,
                  'pytest': RunPyTests,
                  'pylint': RunPyLint,
                  'test': RunTestSuites,
                  'clean': CleanTick},
        classifiers=['Development Status :: 3 - Alpha',
                     'Intended Audience :: Science/Research',
                     'Intended Audience :: Developers',
                     'Programming Language :: C++',
                     'Programming Language :: Python',
                     'Topic :: Software Development',
                     'Topic :: Scientific/Engineering',
                     'Operating System :: POSIX',
                     'Operating System :: Unix',
                     'Operating System :: MacOS',
                     'Programming Language :: Python :: 3.6',
                     'Programming Language :: Python :: 3.7',
                     'Programming Language :: Python :: 3.8',
                     'License :: OSI Approved :: BSD License'],
        )
  