bluepulsar
455 lines
16 KiB
Python
455 lines
16 KiB
Python
"""
|
|
Build script to create PyArmor-obfuscated distributions for multiple Python versions.
|
|
|
|
This script builds separate wheels for Python 3.8, 3.9, and 3.10 for Windows and Linux.
|
|
"""
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import platform
|
|
from pathlib import Path
|
|
|
|
|
|
# Package version
|
|
VERSION = "0.2.0"
|
|
|
|
# Python versions to build for
|
|
PYTHON_VERSIONS = ['3.8', '3.9', '3.10']
|
|
|
|
# Detect platform
|
|
IS_WINDOWS = platform.system() == 'Windows'
|
|
IS_LINUX = platform.system() == 'Linux'
|
|
PLATFORM_NAME = 'win' if IS_WINDOWS else 'linux' if IS_LINUX else 'unknown'
|
|
|
|
|
|
def clean_build_dirs():
|
|
"""Remove previous build artifacts."""
|
|
dirs_to_clean = ['build', 'dist', 'orisys.egg-info', 'dist_obfuscated']
|
|
for dir_name in dirs_to_clean:
|
|
if os.path.exists(dir_name):
|
|
print(f"Cleaning {dir_name}...")
|
|
shutil.rmtree(dir_name)
|
|
|
|
# Ensure dist directory exists with platform subdirectories
|
|
os.makedirs(f'dist/{PLATFORM_NAME}', exist_ok=True)
|
|
|
|
|
|
def get_python_executable(version):
|
|
"""Get the Python executable for a specific version based on platform."""
|
|
# First check if current Python matches the requested version
|
|
current_version = f"{sys.version_info.major}.{sys.version_info.minor}"
|
|
if current_version == version:
|
|
return [sys.executable]
|
|
|
|
if IS_WINDOWS:
|
|
# Windows paths - including conda environments
|
|
username = os.environ.get("USERNAME", "")
|
|
possible_paths = [
|
|
f'py -{version}', # Windows py launcher
|
|
f'python{version}', # Direct version command
|
|
# Conda environments with various naming patterns
|
|
f'C:\\Users\\{username}\\anaconda3\\envs\\py{version.replace(".", "")}\\python.exe',
|
|
f'C:\\Users\\{username}\\anaconda3\\envs\\py{version.replace(".", "")}-env\\python.exe',
|
|
f'C:\\Users\\{username}\\anaconda3\\envs\\python{version.replace(".", "")}\\python.exe',
|
|
f'C:\\Users\\{username}\\anaconda3\\envs\\orisys-py{version.replace(".", "")}\\python.exe',
|
|
f'C:\\Users\\{username}\\miniconda3\\envs\\py{version.replace(".", "")}\\python.exe',
|
|
# Standard Python installations
|
|
f'C:\\Python{version.replace(".", "")}\\python.exe',
|
|
f'C:\\Program Files\\Python{version.replace(".", "")}\\python.exe',
|
|
]
|
|
else:
|
|
# Linux/Unix paths
|
|
possible_paths = [
|
|
f'python{version}',
|
|
f'/usr/bin/python{version}',
|
|
f'/usr/local/bin/python{version}',
|
|
f'~/.pyenv/versions/{version}/bin/python',
|
|
f'/opt/python{version}/bin/python',
|
|
]
|
|
|
|
for path in possible_paths:
|
|
try:
|
|
# Expand user home directory
|
|
if path.startswith('~'):
|
|
path = os.path.expanduser(path)
|
|
|
|
if IS_WINDOWS and path.startswith('py -'):
|
|
# Test Windows py launcher
|
|
result = subprocess.run(
|
|
path.split() + ['-c', 'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")'],
|
|
capture_output=True, text=True, shell=True
|
|
)
|
|
if result.returncode == 0 and result.stdout.strip() == version:
|
|
return path.split()
|
|
else:
|
|
# Check if file exists first
|
|
if not os.path.exists(path):
|
|
continue
|
|
|
|
result = subprocess.run(
|
|
[path, '-c', 'import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")'],
|
|
capture_output=True, text=True
|
|
)
|
|
if result.returncode == 0 and result.stdout.strip() == version:
|
|
return [path]
|
|
except (FileNotFoundError, subprocess.SubprocessError, PermissionError):
|
|
continue
|
|
|
|
return None
|
|
|
|
|
|
def obfuscate_code():
|
|
"""Obfuscate the source code using PyArmor (version-independent)."""
|
|
print("\n=== Obfuscating code with PyArmor ===")
|
|
|
|
# PyArmor 9.x generates version-independent obfuscated code
|
|
# Output directly to dist_obfuscated/src (PyArmor will create orisys subdirectory)
|
|
if IS_WINDOWS:
|
|
cmd = 'pyarmor gen --output dist_obfuscated/src --recursive src/orisys'
|
|
print(f"Running: {cmd}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True, shell=True)
|
|
else:
|
|
cmd = [
|
|
'pyarmor',
|
|
'gen',
|
|
'--output', 'dist_obfuscated/src',
|
|
'--recursive',
|
|
'src/orisys'
|
|
]
|
|
print(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True)
|
|
|
|
if result.returncode != 0:
|
|
print(f"Error obfuscating code:\n{result.stderr}")
|
|
print(f"stdout:\n{result.stdout}")
|
|
sys.exit(1)
|
|
|
|
print("Code obfuscation successful!")
|
|
print(result.stdout)
|
|
return True
|
|
|
|
|
|
def copy_additional_files():
|
|
"""Copy non-Python files that don't need obfuscation."""
|
|
print("\n=== Copying additional files ===")
|
|
|
|
# Ensure configs directory exists in obfuscated output
|
|
# PyArmor should copy it, but we verify and copy if needed
|
|
configs_src = Path('src/orisys/configs')
|
|
configs_dst = Path('dist_obfuscated/src/orisys/configs')
|
|
|
|
if configs_src.exists():
|
|
print(f"Ensuring configs directory is copied...")
|
|
if not configs_dst.exists():
|
|
print(f"Copying configs directory from {configs_src} to {configs_dst}")
|
|
shutil.copytree(configs_src, configs_dst, dirs_exist_ok=True)
|
|
else:
|
|
# Verify JSON files are present
|
|
json_files_src = list(configs_src.glob('*.json'))
|
|
json_files_dst = list(configs_dst.glob('*.json'))
|
|
if len(json_files_dst) < len(json_files_src):
|
|
print(f"Updating configs directory (found {len(json_files_dst)}/{len(json_files_src)} JSON files)")
|
|
shutil.copytree(configs_src, configs_dst, dirs_exist_ok=True)
|
|
else:
|
|
print(f"Configs directory already present with {len(json_files_dst)} JSON files")
|
|
|
|
# Copy config directory (if exists at root level)
|
|
if os.path.exists('config'):
|
|
print("Copying config directory...")
|
|
shutil.copytree('config', 'dist_obfuscated/config', dirs_exist_ok=True)
|
|
|
|
# Copy README and other metadata files
|
|
files_to_copy = ['README.md', 'requirements.txt', 'LICENSE']
|
|
for file in files_to_copy:
|
|
if os.path.exists(file):
|
|
print(f"Copying {file}...")
|
|
shutil.copy(file, f'dist_obfuscated/{file}')
|
|
|
|
|
|
def create_setup_for_obfuscated(python_version=None):
|
|
"""Create a modified setup.py for the obfuscated package."""
|
|
print(f"\n=== Creating setup.py for obfuscated package (Python {python_version or '3.8-3.10'}) ===")
|
|
|
|
if python_version:
|
|
version_constraint = f'=={python_version}.*'
|
|
py_tag = f'py{python_version.replace(".", "")}'
|
|
else:
|
|
version_constraint = '>=3.8,<3.11'
|
|
py_tag = 'py38.py39.py310'
|
|
|
|
setup_content = f'''from setuptools import setup, find_packages
|
|
import os
|
|
from pathlib import Path
|
|
|
|
# Read requirements
|
|
with open('requirements.txt', 'r') as f:
|
|
requirements = [line.strip() for line in f if line.strip() and not line.startswith('#')]
|
|
|
|
# Find all packages including pyarmor_runtime
|
|
packages = find_packages(where="src")
|
|
|
|
# Collect all package data including PyArmor runtime files and configs
|
|
package_data = {{}}
|
|
for pkg in packages:
|
|
pkg_path = Path('src') / pkg.replace('.', '/')
|
|
if pkg_path.exists():
|
|
data_files = []
|
|
|
|
# Include all .pyd, .so, .dll files (PyArmor runtime)
|
|
for pattern in ['*.pyd', '*.so', '*.dll', '*.dylib']:
|
|
data_files.extend([str(f.relative_to(pkg_path)) for f in pkg_path.glob(pattern)])
|
|
|
|
# Include JSON files from configs directory (for orisys.configs package)
|
|
if pkg == 'orisys.configs':
|
|
# Include all JSON files in the configs package directory
|
|
for json_file in pkg_path.glob('*.json'):
|
|
rel_path = json_file.relative_to(pkg_path)
|
|
data_files.append(str(rel_path))
|
|
|
|
# For orisys package, include configs subdirectory JSON files
|
|
if pkg == 'orisys':
|
|
configs_dir = pkg_path / 'configs'
|
|
if configs_dir.exists() and configs_dir.is_dir():
|
|
for json_file in configs_dir.glob('*.json'):
|
|
rel_path = json_file.relative_to(pkg_path)
|
|
data_files.append(str(rel_path))
|
|
|
|
if data_files:
|
|
package_data[pkg] = data_files
|
|
|
|
setup(
|
|
name="orisys",
|
|
version="{VERSION}",
|
|
description="Orisys - Optical Tactile Sensor SDK (Protected)",
|
|
author="Your Name",
|
|
package_dir={{"": "src"}},
|
|
packages=packages,
|
|
package_data=package_data,
|
|
include_package_data=True,
|
|
install_requires=requirements,
|
|
python_requires="{version_constraint}",
|
|
# Include PyArmor runtime files
|
|
zip_safe=False,
|
|
options={{
|
|
'bdist_wheel': {{
|
|
'python_tag': '{py_tag}',
|
|
}}
|
|
}},
|
|
)
|
|
'''
|
|
|
|
with open('dist_obfuscated/setup.py', 'w') as f:
|
|
f.write(setup_content)
|
|
|
|
print("setup.py created successfully!")
|
|
|
|
|
|
def create_manifest_in():
|
|
"""Create MANIFEST.in to ensure JSON files in configs are included."""
|
|
print("\n=== Creating MANIFEST.in ===")
|
|
|
|
manifest_content = """# Include all JSON files in configs directory
|
|
include src/orisys/configs/*.json
|
|
recursive-include src/orisys/configs *.json
|
|
|
|
# Include PyArmor runtime files
|
|
recursive-include src *.pyd
|
|
recursive-include src *.so
|
|
recursive-include src *.dll
|
|
recursive-include src *.dylib
|
|
"""
|
|
|
|
manifest_path = Path('dist_obfuscated/MANIFEST.in')
|
|
with open(manifest_path, 'w') as f:
|
|
f.write(manifest_content)
|
|
|
|
print("MANIFEST.in created successfully!")
|
|
print(manifest_content)
|
|
|
|
|
|
def get_platform_tag():
|
|
"""Get the platform tag for wheel naming."""
|
|
system = platform.system()
|
|
machine = platform.machine().lower()
|
|
|
|
if system == 'Windows':
|
|
if machine in ('amd64', 'x86_64'):
|
|
return 'win_amd64'
|
|
elif machine in ('x86', 'i386', 'i686'):
|
|
return 'win32'
|
|
elif machine in ('arm64', 'aarch64'):
|
|
return 'win_arm64'
|
|
elif system == 'Linux':
|
|
if machine in ('x86_64', 'amd64'):
|
|
return 'manylinux2014_x86_64'
|
|
elif machine in ('aarch64', 'arm64'):
|
|
return 'manylinux2014_aarch64'
|
|
elif machine in ('i386', 'i686'):
|
|
return 'manylinux2014_i686'
|
|
elif system == 'Darwin':
|
|
if machine == 'arm64':
|
|
return 'macosx_11_0_arm64'
|
|
else:
|
|
return 'macosx_10_9_x86_64'
|
|
|
|
return 'any'
|
|
|
|
|
|
def build_wheel_for_version(python_version):
|
|
"""Build the wheel distribution for a specific Python version."""
|
|
print(f"\n{'='*60}")
|
|
print(f"Building wheel for Python {python_version} on {PLATFORM_NAME}")
|
|
print('='*60)
|
|
|
|
python_cmd = get_python_executable(python_version)
|
|
|
|
if not python_cmd:
|
|
print(f"⚠️ Python {python_version} not found on {PLATFORM_NAME}, skipping...")
|
|
return False
|
|
|
|
print(f"Using Python: {' '.join(python_cmd)}")
|
|
|
|
# Verify Python version
|
|
result = subprocess.run(
|
|
python_cmd + ['-c', 'import sys; print(f"Python {sys.version}")'],
|
|
capture_output=True, text=True
|
|
)
|
|
print(result.stdout.strip())
|
|
|
|
# Get platform tag
|
|
plat_tag = get_platform_tag()
|
|
py_tag = f'py{python_version.replace(".", "")}'
|
|
|
|
os.chdir('dist_obfuscated')
|
|
|
|
# Build the wheel using setup.py with explicit tags
|
|
cmd = python_cmd + ['setup.py', 'bdist_wheel',
|
|
'--python-tag', py_tag,
|
|
'--plat-name', plat_tag,
|
|
'--dist-dir', f'../dist/{PLATFORM_NAME}']
|
|
print(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True)
|
|
|
|
os.chdir('..')
|
|
|
|
if result.returncode != 0:
|
|
print(f"❌ Error building wheel for Python {python_version}:\n{result.stderr}")
|
|
return False
|
|
|
|
print(f"✅ Wheel for Python {python_version} on {PLATFORM_NAME} built successfully!")
|
|
print(f" Expected: orisys-{VERSION}-{py_tag}-none-{plat_tag}.whl")
|
|
return True
|
|
|
|
|
|
def build_universal_wheel():
|
|
"""Build a single universal wheel compatible with all Python versions."""
|
|
print(f"\n{'='*60}")
|
|
print(f"Building Universal Wheel (Python 3.8-3.10) for {PLATFORM_NAME}")
|
|
print('='*60)
|
|
|
|
os.chdir('dist_obfuscated')
|
|
|
|
# Build the wheel
|
|
cmd = [sys.executable, '-m', 'pip', 'wheel', '.', '--no-deps', '-w', f'../dist/{PLATFORM_NAME}']
|
|
print(f"Running: {' '.join(cmd)}")
|
|
result = subprocess.run(cmd, capture_output=True, text=True)
|
|
|
|
os.chdir('..')
|
|
|
|
if result.returncode != 0:
|
|
print(f"❌ Error building universal wheel:\n{result.stderr}")
|
|
return False
|
|
|
|
print(f"✅ Universal wheel for {PLATFORM_NAME} built successfully!")
|
|
print(result.stdout)
|
|
return True
|
|
|
|
|
|
def main():
|
|
"""Main build process."""
|
|
import argparse
|
|
|
|
parser = argparse.ArgumentParser(description='Build orisys package with PyArmor')
|
|
parser.add_argument('--mode', choices=['universal', 'multi-version', 'current'], default='current',
|
|
help='Build mode: universal (one wheel for all), multi-version (separate wheels), current (use current Python only)')
|
|
parser.add_argument('--versions', nargs='+', default=PYTHON_VERSIONS,
|
|
help='Python versions to build for (only for multi-version mode)')
|
|
|
|
args = parser.parse_args()
|
|
|
|
# Get current Python version
|
|
current_py_version = f"{sys.version_info.major}.{sys.version_info.minor}"
|
|
|
|
print("=" * 60)
|
|
print("Building Orisys Package with PyArmor Obfuscation")
|
|
print(f"Platform: {PLATFORM_NAME} ({platform.system()})")
|
|
print(f"Current Python: {current_py_version} ({sys.executable})")
|
|
|
|
if args.mode == 'current':
|
|
print(f"Mode: Building for current Python version ({current_py_version}) only")
|
|
args.versions = [current_py_version]
|
|
# Use multi-version logic but with current version only
|
|
build_mode = 'multi-version'
|
|
else:
|
|
print(f"Python Versions: {', '.join(args.versions)}")
|
|
print(f"Mode: {args.mode}")
|
|
build_mode = args.mode
|
|
|
|
print("=" * 60)
|
|
|
|
# Ensure we're in the right directory
|
|
script_dir = Path(__file__).parent
|
|
os.chdir(script_dir)
|
|
|
|
# Step 1: Clean previous builds
|
|
clean_build_dirs()
|
|
|
|
# Step 2: Obfuscate the code (once, version-independent)
|
|
if not obfuscate_code():
|
|
print("\n❌ Build failed during obfuscation!")
|
|
sys.exit(1)
|
|
|
|
# Step 3: Copy additional files (including configs)
|
|
copy_additional_files()
|
|
|
|
# Step 3.5: Create MANIFEST.in to ensure JSON files are included
|
|
create_manifest_in()
|
|
|
|
# Step 4 & 5: Build based on mode
|
|
if build_mode == 'universal':
|
|
# Build one wheel for all Python versions
|
|
create_setup_for_obfuscated()
|
|
if not build_universal_wheel():
|
|
print("\n❌ Build failed!")
|
|
sys.exit(1)
|
|
else:
|
|
# Build separate wheels for each Python version (or just current)
|
|
success_count = 0
|
|
for version in args.versions:
|
|
create_setup_for_obfuscated(version)
|
|
if build_wheel_for_version(version):
|
|
success_count += 1
|
|
|
|
if success_count == 0:
|
|
print("\n❌ Build failed - no wheels created!")
|
|
sys.exit(1)
|
|
|
|
print(f"\n✅ Successfully built {success_count}/{len(args.versions)} wheels")
|
|
|
|
print("\n" + "=" * 60)
|
|
print("✅ Build completed successfully!")
|
|
print("=" * 60)
|
|
print(f"\nPlatform: {PLATFORM_NAME}")
|
|
print(f"Obfuscated source: dist_obfuscated/")
|
|
print(f"Distribution packages: dist/{PLATFORM_NAME}/")
|
|
print("\nGenerated wheels:")
|
|
for wheel in Path(f'dist/{PLATFORM_NAME}').glob('*.whl'):
|
|
print(f" - {wheel.name}")
|
|
print("\nInstall with:")
|
|
print(f" pip install dist/{PLATFORM_NAME}/orisys-{VERSION}-*.whl")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|