"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "python/setup.py" between
prophet-1.0.tar.gz and prophet-1.1.tar.gz

About: Prophet is a tool for producing high quality forecasts for time series data that has multiple seasonality with linear or non-linear growth.

setup.py  (prophet-1.0)	:	setup.py  (prophet-1.1)
# Copyright (c) Facebook, Inc. and its affiliates.		# Copyright (c) Facebook, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the		# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.		# LICENSE file in the root directory of this source tree.
import os.path
import platform
import sys
import os		import os
from pkg_resources import (		import sys
normalize_path,		import platform
working_set,		from pathlib import Path
add_activation_listener,		from shutil import copy, copytree, rmtree
require,		from typing import List
)
from setuptools import setup, find_packages		from pkg_resources import add_activation_listener, normalize_path, require, work
		ing_set
		from setuptools import find_packages, setup, Extension
		from setuptools.command.build_ext import build_ext
from setuptools.command.build_py import build_py		from setuptools.command.build_py import build_py
from setuptools.command.develop import develop		from setuptools.command.develop import develop
from setuptools.command.test import test as test_command		from setuptools.command.test import test as test_command
from typing import List
PLATFORM = 'unix'		MODEL_DIR = "stan"
if platform.platform().startswith('Win'):		MODEL_TARGET_DIR = os.path.join("prophet", "stan_model")
PLATFORM = 'win'
MODEL_DIR = os.path.join('stan', PLATFORM)		CMDSTAN_VERSION = "2.26.1"
MODEL_TARGET_DIR = os.path.join('prophet', 'stan_model')		BINARIES_DIR = "bin"
		BINARIES = ["diagnose", "print", "stanc", "stansummary"]
		TBB_PARENT = "stan/lib/stan_math/lib"
		TBB_DIRS = ["tbb", "tbb_2019_U8"]
		def prune_cmdstan(cmdstan_dir: str) -> None:
		"""
		Keep only the cmdstan executables and tbb files (minimum required to run a c
		mdstanpy commands on a pre-compiled model).
		"""
		original_dir = Path(cmdstan_dir).resolve()
		parent_dir = original_dir.parent
		temp_dir = parent_dir / "temp"
		if temp_dir.is_dir():
		rmtree(temp_dir)
		temp_dir.mkdir()
		print("Copying ", original_dir, " to ", temp_dir, " for pruning")
		copytree(original_dir / BINARIES_DIR, temp_dir / BINARIES_DIR)
		for f in (temp_dir / BINARIES_DIR).iterdir():
		if f.is_dir():
		rmtree(f)
		elif f.is_file() and f.stem not in BINARIES:
		os.remove(f)
		for tbb_dir in TBB_DIRS:
		copytree(original_dir / TBB_PARENT / tbb_dir, temp_dir / TBB_PARENT / tb
		b_dir)
		rmtree(original_dir)
		temp_dir.rename(original_dir)
		def repackage_cmdstan():
		return os.environ.get("PROPHET_REPACKAGE_CMDSTAN", "").lower() not in ["fals
		e", "0"]
		def maybe_install_cmdstan_toolchain():
		"""Install C++ compilers required to build stan models on Windows machines."
		""
		import cmdstanpy
		from cmdstanpy.install_cxx_toolchain import main as _install_cxx_toolchain
		try:
		cmdstanpy.utils.cxx_toolchain_path()
		except Exception:
		_install_cxx_toolchain({"version": None, "dir": None, "verbose": True})
		cmdstanpy.utils.cxx_toolchain_path()
		def install_cmdstan_deps(cmdstan_dir: Path):
		import cmdstanpy
		from multiprocessing import cpu_count
		if repackage_cmdstan():
		if platform.platform().startswith("Win"):
		maybe_install_cmdstan_toolchain()
		print("Installing cmdstan to", cmdstan_dir)
		if os.path.isdir(cmdstan_dir):
		rmtree(cmdstan_dir)
		if not cmdstanpy.install_cmdstan(
		version=CMDSTAN_VERSION,
		dir=cmdstan_dir.parent,
		overwrite=True,
		verbose=True,
		cores=cpu_count(),
		progress=True,
		):
		raise RuntimeError("CmdStan failed to install in repackaged director
		y")
		def build_cmdstan_model(target_dir):
		"""
		Rebuild cmdstan in the build environment, then use this installation to comp
		ile the stan model.
		The stan model is copied to {target_dir}/prophet_model.bin
		The cmdstan files required to run cmdstanpy commands are copied to {target_d
		ir}/cmdstan-{version}.
		Parameters
		----------
		target_dir: Directory to copy the compiled model executable and core cmdstan
		files to.
		"""
		import cmdstanpy
		cmdstan_dir = (Path(target_dir) / f"cmdstan-{CMDSTAN_VERSION}").resolve()
		install_cmdstan_deps(cmdstan_dir)
		model_name = "prophet.stan"
		target_name = "prophet_model.bin"
		sm = cmdstanpy.CmdStanModel(stan_file=os.path.join(MODEL_DIR, model_name))
		copy(sm.exe_file, os.path.join(target_dir, target_name))
		# Clean up
		for f in Path(MODEL_DIR).iterdir():
		if f.is_file() and f.name != model_name:
		os.remove(f)
		if repackage_cmdstan():
		prune_cmdstan(cmdstan_dir)
def get_backends_from_env() -> List[str]:		def get_backends_from_env() -> List[str]:
from prophet.models import StanBackendEnum		return os.environ.get("STAN_BACKEND", "CMDSTANPY").split(",")
return os.environ.get("STAN_BACKEND", StanBackendEnum.PYSTAN.name).split(","
)
def build_models(target_dir):		def build_models(target_dir):
from prophet.models import StanBackendEnum		print(f"Compiling cmdstanpy model")
for backend in get_backends_from_env():		build_cmdstan_model(target_dir)
StanBackendEnum.get_backend_class(backend).build_model(target_dir, MODEL
_DIR)		if 'PYSTAN' in get_backends_from_env():
		raise ValueError("PyStan backend is not supported for Prophet >= 1.1")
class BuildPyCommand(build_py):		class BuildPyCommand(build_py):
"""Custom build command to pre-compile Stan models."""		"""Custom build command to pre-compile Stan models."""
def run(self):		def run(self):
if not self.dry_run:		if not self.dry_run:
target_dir = os.path.join(self.build_lib, MODEL_TARGET_DIR)		target_dir = os.path.join(self.build_lib, MODEL_TARGET_DIR)
self.mkpath(target_dir)		self.mkpath(target_dir)
build_models(target_dir)		build_models(target_dir)
build_py.run(self)		build_py.run(self)
		class BuildExtCommand(build_ext):
		"""Ensure built extensions are added to the correct path in the wheel."""
		def run(self):
		pass
class DevelopCommand(develop):		class DevelopCommand(develop):
"""Custom develop command to pre-compile Stan models in-place."""		"""Custom develop command to pre-compile Stan models in-place."""
def run(self):		def run(self):
if not self.dry_run:		if not self.dry_run:
target_dir = os.path.join(self.setup_path, MODEL_TARGET_DIR)		target_dir = os.path.join(self.setup_path, MODEL_TARGET_DIR)
self.mkpath(target_dir)		self.mkpath(target_dir)
build_models(target_dir)		build_models(target_dir)
develop.run(self)		develop.run(self)
class TestCommand(test_command):		class TestCommand(test_command):
user_options = [		user_options = [
('test-module=', 'm', "Run 'test_suite' in specified module"),		("test-module=", "m", "Run 'test_suite' in specified module"),
('test-suite=', 's',		(
"Run single test, case or suite (e.g. 'module.test_suite')"),		"test-suite=",
('test-runner=', 'r', "Test runner to use"),		"s",
('test-slow', 'w', "Test slow suites (default off)"),		"Run single test, case or suite (e.g. 'module.test_suite')",
		),
		("test-runner=", "r", "Test runner to use"),
		("test-slow", "w", "Test slow suites (default off)"),
]		]
test_slow = None		test_slow = None
def initialize_options(self):		def initialize_options(self):
super(TestCommand, self).initialize_options()		super(TestCommand, self).initialize_options()
self.test_slow = False		self.test_slow = False
def finalize_options(self):		def finalize_options(self):
super(TestCommand, self).finalize_options()		super(TestCommand, self).finalize_options()
if self.test_slow is None:		if self.test_slow is None:
self.test_slow = getattr(self.distribution, 'test_slow', False)		self.test_slow = getattr(self.distribution, "test_slow", False)
"""We must run tests on the build directory, not source."""		"""We must run tests on the build directory, not source."""
def with_project_on_sys_path(self, func):		def with_project_on_sys_path(self, func):
# Ensure metadata is up-to-date		# Ensure metadata is up-to-date
self.reinitialize_command('build_py', inplace=0)		self.reinitialize_command("build_py", inplace=0)
self.run_command('build_py')		self.run_command("build_py")
bpy_cmd = self.get_finalized_command("build_py")		bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)		build_path = normalize_path(bpy_cmd.build_lib)
# Build extensions		# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)		self.reinitialize_command("egg_info", egg_base=build_path)
self.run_command('egg_info')		self.run_command("egg_info")
self.reinitialize_command('build_ext', inplace=0)		self.reinitialize_command("build_ext", inplace=0)
self.run_command('build_ext')		self.run_command("build_ext")
ei_cmd = self.get_finalized_command("egg_info")		ei_cmd = self.get_finalized_command("egg_info")
old_path = sys.path[:]		old_path = sys.path[:]
old_modules = sys.modules.copy()		old_modules = sys.modules.copy()
try:		try:
sys.path.insert(0, normalize_path(ei_cmd.egg_base))		sys.path.insert(0, normalize_path(ei_cmd.egg_base))
working_set.__init__()		working_set.__init__()
add_activation_listener(lambda dist: dist.activate())		add_activation_listener(lambda dist: dist.activate())
require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))		require("%s==%s" % (ei_cmd.egg_name, ei_cmd.egg_version))
func()		func()
finally:		finally:
sys.path[:] = old_path		sys.path[:] = old_path
sys.modules.clear()		sys.modules.clear()
sys.modules.update(old_modules)		sys.modules.update(old_modules)
working_set.__init__()		working_set.__init__()
with open('README.md', 'r', encoding='utf-8') as f:		with open("README.md", "r", encoding="utf-8") as f:
long_description = f.read()		long_description = f.read()
with open('requirements.txt', 'r') as f:		with open("requirements.txt", "r") as f:
install_requires = f.read().splitlines()		install_requires = f.read().splitlines()
setup(		setup(
name='prophet',		name="prophet",
version='1.0.1',		version="1.1",
description='Automatic Forecasting Procedure',		description="Automatic Forecasting Procedure",
url='https://facebook.github.io/prophet/',		url="https://facebook.github.io/prophet/",
author='Sean J. Taylor <sjtz@pm.me>, Ben Letham <bletham@fb.com>',		project_urls={
author_email='sjtz@pm.me',		"Source": "https://github.com/facebook/prophet",
license='MIT',		},
		author="Sean J. Taylor <sjtz@pm.me>, Ben Letham <bletham@fb.com>",
		author_email="sjtz@pm.me",
		license="MIT",
packages=find_packages(),		packages=find_packages(),
setup_requires=[
],
install_requires=install_requires,		install_requires=install_requires,
python_requires='>=3',		python_requires=">=3.7",
zip_safe=False,		zip_safe=False,
include_package_data=True,		include_package_data=True,
		ext_modules=[Extension("prophet.stan_model", [])],
cmdclass={		cmdclass={
'build_py': BuildPyCommand,		"build_ext": BuildExtCommand,
'develop': DevelopCommand,		"build_py": BuildPyCommand,
'test': TestCommand,		"develop": DevelopCommand,
		"test": TestCommand,
},		},
test_suite='prophet.tests',		test_suite="prophet.tests",
classifiers=[		classifiers=[
'Programming Language :: Python',		"Programming Language :: Python",
'Programming Language :: Python :: 3',		"Programming Language :: Python :: 3",
'Programming Language :: Python :: 3.7',		"Programming Language :: Python :: 3.7",
		"Programming Language :: Python :: 3.8",
		"Programming Language :: Python :: 3.9",
		"Programming Language :: Python :: 3.10",
],		],
long_description=long_description,		long_description=long_description,
long_description_content_type='text/markdown',		long_description_content_type="text/markdown",
)		)
End of changes. 24 change blocks.
56 lines changed or deleted		165 lines changed or added

---