def change_log_generate(package_name):
from pypi_tools.pypi import PyPIClient
client = PyPIClient()
try:
client.get_ordered_versions(package_name)
except:
return " - Initial Release"
else:
return change_log_main(f"{package_name}:pypi",
f"{package_name}:latest")
def process_requirement(req, dependency_type):
# this method finds either latest or minimum version of a package that is available on PyPI
# find package name and requirement specifier from requires
pkg_name, spec = parse_req(req)
# get available versions on PyPI
client = PyPIClient()
versions = [str(v) for v in client.get_ordered_versions(pkg_name)]
logging.info("Versions available on PyPI for %s: %s", pkg_name, versions)
if pkg_name in MINIMUM_VERSION_SUPPORTED_OVERRIDE:
versions = [v for v in versions if parse_version(v) >= parse_version(MINIMUM_VERSION_SUPPORTED_OVERRIDE[pkg_name])]
# Search from lowest to latest in case of finding minimum dependency
# Search from latest to lowest in case of finding latest required version
# reverse the list to get latest version first
if dependency_type == "Latest":
versions.reverse()
# return first version that matches specifier in <package-name>==<version> format
for version in versions:
if version in spec:
logging.info("Found %s version %s that matches specifier %s", dependency_type, version, spec)
return pkg_name + "==" + version
logging.error("No version is found on PyPI for package %s that matches specifier %s", pkg_name, spec)
return ""
def is_required_version_on_pypi(package_name, spec):
client = PyPIClient()
versions = [
str(v) for v in client.get_ordered_versions(package_name)
if str(v) in spec
]
return versions
def is_required_version_on_pypi(package_name, spec):
client = PyPIClient()
try:
pypi_results = client.get_ordered_versions(package_name)
except:
pypi_results = []
versions = [str(v) for v in pypi_results if str(v) in spec]
return versions
def is_required_version_on_pypi(package_name, spec):
from pypi_tools.pypi import PyPIClient
client = PyPIClient()
versions = []
try:
versions = [str(v) for v in client.get_ordered_versions(package_name) if str(v) in spec]
except:
logging.error("Package {} is not found on PyPI", package_name)
return versions
def get_release_tag(dep_pkg_name, isLatest):
# get versions from pypi and find latest
# delayed import until sdk tools are installed on virtual env
from pypi_tools.pypi import PyPIClient
client = PyPIClient()
versions = []
try:
versions = [str(v) for v in client.get_ordered_versions(dep_pkg_name)]
logging.info("Versions available on PyPI for {0} are: {1}".format(
dep_pkg_name, versions))
except:
logging.error(
"Package {} is not available on PyPI".format(dep_pkg_name))
return None
# filter excluded versions
if dep_pkg_name in EXCLUDED_PACKAGE_VERSIONS:
versions = [
v for v in versions
if parse(v) > parse(EXCLUDED_PACKAGE_VERSIONS[dep_pkg_name])
]
logging.info("Filtered versions for {0} is: {1}".format(
dep_pkg_name, versions))
if not versions:
logging.info(
"Released version info for package {} is not available".format(
dep_pkg_name))
# This is not a hard error. We can run into this situation when a new package is added to repo and not yet released
return
# find latest version
logging.info("Looking for {} released version".format(
"Latest" if isLatest == True else "Oldest"))
if isLatest == True:
versions.reverse()
else:
# find oldest GA version by filtering out all preview versions
versions = [v for v in versions if parse(v).is_prerelease == False]
if (len(versions) < 2):
logging.info(
"Only one or no released GA version found for package {}".
format(dep_pkg_name))
return
version = versions[0]
# create tag in <pkg_name>_version format
tag_name = "{0}_{1}".format(dep_pkg_name, version)
logging.info("Release tag for package [{0}] is [{1}]".format(
dep_pkg_name, tag_name))
return tag_name
def main(input_parameter: str,
version: Optional[str] = None,
no_venv: bool = False,
pypi: bool = False,
last_pypi: bool = False,
output: str = None):
package_name, module_name = parse_input(input_parameter)
path_to_package = resolve_package_directory(package_name)
if (version or pypi or last_pypi) and not no_venv:
if version:
versions = [version]
else:
_LOGGER.info(f"Download versions of {package_name} on PyPI")
from pypi_tools.pypi import PyPIClient
client = PyPIClient()
versions = [
str(v) for v in client.get_ordered_versions(package_name)
]
_LOGGER.info(f"Got {versions}")
if last_pypi:
_LOGGER.info(f"Only keep last PyPI version")
versions = filter_track2_versions(package_name, versions)
versions = [versions[-1]]
for version in versions:
_LOGGER.info(
f"Installing version {version} of {package_name} in a venv")
with create_venv_with_package([f"{package_name}=={version}"
]) as venv:
args = [
venv.env_exe, __file__, "--no-venv", "--version", version,
input_parameter
]
if output is not None:
args.append("--output=" + output)
try:
subprocess.check_call(args)
except subprocess.CalledProcessError:
# If it fail, just assume this version is too old to get an Autorest report
_LOGGER.warning(
f"Version {version} seems to be too old to build a report (probably not Autorest based)"
)
# Files have been written by the subprocess
return
modules = find_autorest_generated_folder(module_name)
result = []
version = version or "latest"
output_folder = Path(path_to_package) / Path("code_reports") / Path(
version)
output_folder.mkdir(parents=True, exist_ok=True)
for module_name in modules:
_LOGGER.info(f"Working on {module_name}")
report = create_report(module_name)
module_for_path = get_sub_module_part(package_name, module_name)
if module_for_path:
output_filename = output_folder / Path(module_for_path + ".json")
else:
if output is not None:
output_filename = output
else:
output_filename = output_folder / Path("report.json")
with open(output_filename, "w") as fd:
json.dump(report, fd, indent=2)
_LOGGER.info(f"Report written to {output_filename}")
result.append(output_filename)
if len(result) > 1:
merged_report = merge_report(result)
if output is not None:
output_filename = output
else:
output_filename = output_folder / Path("merged_report.json")
with open(output_filename, "w") as fd:
json.dump(merged_report, fd, indent=2)
_LOGGER.info(f"Merged report written to {output_filename}")
return result
fr"docker create -it --rm -h Change_log --name Change_log -v {docker_path}:/_ l601306339/autorest"
)
sp.call("docker start Change_log")
# install azure tools
sp.call(f'{docker_cmd} "python _/scripts/dev_setup.py -p azure-core" ')
# get all azure-mgmt-package paths
in_files = glob.glob(str(Path(f'{docker_path}/sdk/*/azure-mgmt-*')))
for i in in_files:
path = Path(i)
service_name = path.parts[-1]
# get package version in pypi
client = PyPIClient()
versions = [str(v) for v in client.get_ordered_versions(service_name)]
if len(versions) >= 2:
older_version = versions[-2]
last_version = versions[-1]
# generate code_report
cmd_last_version = fr'{docker_cmd} "cd _/ && python -m packaging_tools.code_report {service_name} --version={last_version}"'
cmd_older_version = fr'{docker_cmd} "cd _/ && python -m packaging_tools.code_report {service_name} --version={older_version}"'
try:
last_code_report_info = create_code_report(
cmd_last_version, service_name)
older_code_report_info = create_code_report(
cmd_older_version, service_name)
# get code_report path
route_last_version = find_report_name(last_code_report_info)
def main(
input_parameter: str,
version: Optional[str] = None,
no_venv: bool = False,
pypi: bool = False,
last_pypi: bool = False,
output: Optional[str] = None,
metadata_path: Optional[str] = None,
):
output_msg = output if output else "default folder"
_LOGGER.info(
f"Building code report of {input_parameter} for version {version} in {output_msg} ({no_venv}/{pypi}/{last_pypi})"
)
package_name, module_name = parse_input(input_parameter)
path_to_package = resolve_package_directory(package_name)
output_filename = ""
result = []
if (version or pypi or last_pypi) and not no_venv:
if version:
versions = [version]
else:
_LOGGER.info(f"Download versions of {package_name} on PyPI")
from pypi_tools.pypi import PyPIClient
client = PyPIClient()
versions = [
str(v) for v in client.get_ordered_versions(package_name)
]
_LOGGER.info(f"Got {versions}")
if last_pypi:
_LOGGER.info(f"Only keep last PyPI version")
versions = [versions[-1]]
for version in versions:
_LOGGER.info(
f"Installing version {version} of {package_name} in a venv")
with create_venv_with_package([
f"{package_name}=={version}"
]) as venv, tempfile.TemporaryDirectory() as temp_dir:
metadata_path = str(Path(temp_dir, f"metadata_{version}.json"))
args = [
venv.env_exe,
__file__,
"--no-venv",
"--version",
version,
"--metadata",
metadata_path,
input_parameter,
]
if output is not None:
args.append("--output=" + output)
try:
subprocess.check_call(args)
except subprocess.CalledProcessError:
# If it fail, just assume this version is too old to get an Autorest report
_LOGGER.warning(
f"Version {version} seems to be too old to build a report (probably not Autorest based)"
)
# Files have been written by the subprocess
with open(metadata_path, "r") as metadata_fd:
result.extend(json.load(metadata_fd)["reports_path"])
# Files have been written by the subprocess
return result
modules = find_autorest_generated_folder(module_name)
version = version or "latest"
output_folder = Path(path_to_package) / Path("code_reports") / Path(
version)
output_folder.mkdir(parents=True, exist_ok=True)
for module_name in modules:
_LOGGER.info(f"Working on {module_name}")
report = create_report(module_name)
module_for_path = get_sub_module_part(package_name, module_name)
if module_for_path:
output_filename = output_folder / Path(module_for_path + ".json")
else:
if output is not None:
output_filename = output
else:
output_filename = output_folder / Path("report.json")
with open(output_filename, "w") as fd:
json.dump(report, fd, indent=2)
_LOGGER.info(f"Report written to {output_filename}")
result.append(str(output_filename))
if len(result) > 1:
merged_report = merge_report(result)
if output is not None:
output_filename = output
else:
output_filename = output_folder / Path("merged_report.json")
with open(output_filename, "w") as fd:
json.dump(merged_report, fd, indent=2)
_LOGGER.info(f"Merged report written to {output_filename}")
result = [str(output_filename)]
if metadata_path:
metadata = {"reports_path": result} # Prepare metadata
with open(metadata_path, "w") as metadata_fd:
_LOGGER.info(f"Writing metadata: {metadata}")
json.dump(metadata, metadata_fd)
return result