File _service:obs_scm:sle-prjmgr-tools-1670322149.d3... of Package sle-prjmgr-tools

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:sle-prjmgr-tools-1670322149.d38bfb5.obscpio of Package sle-prjmgr-tools (Revision cf9d71267b79047ad2bcca0c7d495023)

Currently displaying revision cf9d71267b79047ad2bcca0c7d495023 , Show latest

07070100000000000041ED000000000000000000000004638F17E500000000000000000000000000000000000000000000002C00000000sle-prjmgr-tools-1670322149.d38bfb5/.github07070100000001000041ED000000000000000000000002638F17E500000000000000000000000000000000000000000000003B00000000sle-prjmgr-tools-1670322149.d38bfb5/.github/ISSUE_TEMPLATE07070100000002000081A4000000000000000000000001638F17E50000023F000000000000000000000000000000000000004900000000sle-prjmgr-tools-1670322149.d38bfb5/.github/ISSUE_TEMPLATE/bug_report.md---
name: Bug report
about: Create a report to help us improve
title: ''
labels: bug
assignees: ''

---

## Describe the bug

A clear and concise description of what the bug is.

## To Reproduce

Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

## Expected behavior

A clear and concise description of what you expected to happen.

## Logs

If applicable, add logs to help explain your problem.

## Version

```
<output of sle-prjmgr-tools -v>
```

## Additional context

Add any other context about the problem here.
07070100000003000081A4000000000000000000000001638F17E50000025B000000000000000000000000000000000000004E00000000sle-prjmgr-tools-1670322149.d38bfb5/.github/ISSUE_TEMPLATE/feature_request.md---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: enhancement
assignees: ''

---

## Is your feature request related to a problem? Please describe

A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

## Describe the solution you'd like

A clear and concise description of what you want to happen.

## Describe alternatives you've considered

A clear and concise description of any alternative solutions or features you've considered.

## Additional context

Add any other context or screenshots about the feature request here.
07070100000004000041ED000000000000000000000002638F17E500000000000000000000000000000000000000000000003600000000sle-prjmgr-tools-1670322149.d38bfb5/.github/workflows07070100000005000081A4000000000000000000000001638F17E50000060C000000000000000000000000000000000000004000000000sle-prjmgr-tools-1670322149.d38bfb5/.github/workflows/build.ymlname: Build

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build_rpm:
    name: Build RPM in Docker container
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2
      - name: Build Docker image
        uses: docker/build-push-action@v3
        with:
          context: .
          file: docker/build.dockerfile
          push: false
          load: true
          tags: sle-prjmgr-tools-builder
      - name: Build RPM inside Docker image
        run: docker run --rm -v $PWD:/code sle-prjmgr-tools-builder
      - name: Store built RPMs
        uses: actions/upload-artifact@v3
        with:
          name: rpms
          path: rpm-build/*.rpm
  install_rpm:
    name: Install previously built RPM
    needs: build_rpm
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Download a single artifact
        uses: actions/download-artifact@v3
        with:
          name: rpms
          path: rpm-build
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2
      - name: Build Docker image
        uses: docker/build-push-action@v3
        with:
          context: .
          file: docker/install-check.dockerfile
          push: false
          load: true
          tags: sle-prjmgr-tools-install-check
      - name: Try installing the RPM in a openSUSE Leap image
        run: docker run --rm -v $PWD/rpm-build:/rpms sle-prjmgr-tools-install-check
07070100000006000081A4000000000000000000000001638F17E500000818000000000000000000000000000000000000004100000000sle-prjmgr-tools-1670322149.d38bfb5/.github/workflows/codeql.yml# For most projects, this workflow file will not need changing; you simply need
# to commit it to your repository.
#
# You may wish to alter this file to override the set of languages analyzed,
# or to provide custom queries or build logic.
#
# ******** NOTE ********
# We have attempted to detect the languages in your repository. Please check
# the `language` matrix defined below to confirm you have the correct set of
# supported CodeQL languages.
#
name: "CodeQL"

on:
  push:
    branches: [ "main" ]
  pull_request:
    # The branches below must be a subset of the branches above
    branches: [ "main" ]
  schedule:
    - cron: '42 4 * * 4'

jobs:
  analyze:
    name: Analyze
    runs-on: ubuntu-latest
    permissions:
      actions: read
      contents: read
      security-events: write

strategy:
      fail-fast: false
      matrix:
        language: [ 'python' ]

steps:
    - name: Checkout repository
      uses: actions/checkout@v3

# Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
      uses: github/codeql-action/init@v2
      with:
        languages: ${{ matrix.language }}
        # If you wish to specify custom queries, you can do so here or in a config file.
        # By default, queries listed here will override any specified in a config file.
        # Prefix the list here with "+" to use these queries and those in the config file.

# Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
        # queries: security-extended,security-and-quality

# Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
      uses: github/codeql-action/autobuild@v2

- name: Perform CodeQL Analysis
      uses: github/codeql-action/analyze@v2
      with:
        category: "/language:${{matrix.language}}"
07070100000007000081A4000000000000000000000001638F17E5000004A4000000000000000000000000000000000000003F00000000sle-prjmgr-tools-1670322149.d38bfb5/.github/workflows/lint.ymlname: Linting

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  python_pylint:
    name: pylint
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.6'
          cache: 'pip' # caching pip dependencies
          cache-dependency-path: '**/setup.cfg'
      - run: pip install .[lint]
      - run: pylint --rcfile=.pylintrc sle_prjmgr_tools
  python_mypy:
    name: mypy
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: pip install .[lint]
      - uses: actions/setup-python@v4
        with:
          python-version: '3.8' # We need Python 3.8, so we can install types-lxml
          cache: 'pip' # caching pip dependencies
          cache-dependency-path: '**/setup.cfg'
      - run: pip install .[lint]
      - run: pip install types-lxml
      - run: python -m mypy sle_prjmgr_tools
  python_black:
    name: black formatter
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: psf/black@stable
        with:
          options: "--check --safe --verbose"
          version: "22.8.0"
07070100000008000081A4000000000000000000000001638F17E500000487000000000000000000000000000000000000004700000000sle-prjmgr-tools-1670322149.d38bfb5/.github/workflows/release_pypi.ymlname: Publish Python distributions to PyPI

on:
  push:
    branches:
      - main

jobs:
  build-n-publish:
    name: Build and publish Python distributions to PyPI
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-python@v4
        with:
          python-version: '3.11'
          cache: 'pip'
          cache-dependency-path: '**/setup.cfg'
      - name: Install build dependencies
        run: pip install setuptools wheel
      - name: Fetch date for version bump
        run: echo "new_version=$(date +'%Y%m%d%H%M')" >> $GITHUB_ENV
      - name: Replace version in __init__.py
        run: sed -i '/__version__ = "[0-9].[0-9].[0-9]/s/.$/.'${{ env.new_version }}'"/g' sle_prjmgr_tools/__init__.py
      - name: Install Deps with pip
        run: pip install .
      - name: Install pypa/build
        run: python -m pip install build --user
      - name: Build a binary wheel and a source tarball
        run: python setup.py sdist bdist_wheel
      - name: Publish distribution to PyPI
        uses: pypa/gh-action-pypi-publish@release/v1
        with:
          password: ${{ secrets.PYPI_API_TOKEN }}
07070100000009000081A4000000000000000000000001638F17E5000001CE000000000000000000000000000000000000003F00000000sle-prjmgr-tools-1670322149.d38bfb5/.github/workflows/test.ymlname: Testing

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  python_pytest:
    name: pytest
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.6'
          cache: 'pip' # caching pip dependencies
          cache-dependency-path: '**/setup.cfg'
      - run: pip install .[test]
      - run: pytest -v --junitxml=report.xml
0707010000000A000081A4000000000000000000000001638F17E5000008D1000000000000000000000000000000000000002F00000000sle-prjmgr-tools-1670322149.d38bfb5/.gitignore### Custom folders

rpm-build

### IDEs

# We want everything from IDEA based ideas ignored
.idea
# We want everything from Jetbrains Fleet ignored
.fleet
# We want everything from MS VSCode ignored
.vscode

### Python template
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

# C extensions
*.so

# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST

# PyInstaller
#  Usually these files are written by a python script from a template
#  before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest

# Installer logs
pip-log.txt
pip-delete-this-directory.txt

# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py,cover
.hypothesis/
.pytest_cache/
cover/

# Translations
*.mo
*.pot

# Django stuff:
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal

# Flask stuff:
instance/
.webassets-cache

# Scrapy stuff:
.scrapy

# Sphinx documentation
docs/_build/

# PyBuilder
.pybuilder/
target/

# Jupyter Notebook
.ipynb_checkpoints

# IPython
profile_default/
ipython_config.py

# pyenv
#   For a library or package, you might want to ignore these files since the code is
#   intended to run in multiple environments; otherwise, check them in:
# .python-version

# pipenv
#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
#   However, in case of collaboration, if having platform-specific dependencies or dependencies
#   having no cross-platform support, pipenv may install dependencies that don't work, or not
#   install all needed dependencies.
#Pipfile.lock

# PEP 582; used by e.g. github.com/David-OConnor/pyflow
__pypackages__/

# Celery stuff
celerybeat-schedule
celerybeat.pid

# SageMath parsed files
*.sage.py

# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/

# Spyder project settings
.spyderproject
.spyproject

# Rope project settings
.ropeproject

# mkdocs documentation
/site

# mypy
.mypy_cache/
.dmypy.json
dmypy.json

# Pyre type checker
.pyre/

# pytype static type analyzer
.pytype/

# Cython debug symbols
cython_debug/

0707010000000B000041ED000000000000000000000002638F17E500000000000000000000000000000000000000000000002900000000sle-prjmgr-tools-1670322149.d38bfb5/.obs0707010000000C000081A4000000000000000000000001638F17E500000263000000000000000000000000000000000000003700000000sle-prjmgr-tools-1670322149.d38bfb5/.obs/workflows.yml---
pr:
  steps:
  - link_package:
      source_project: openSUSE:Tools
      source_package: sle-prjmgr-tools
      target_project: openSUSE:Tools:OSRT:TestGithub
  - configure_repositories:
      project: openSUSE:Tools:OSRT:TestGithub
      repositories:
      - name: openSUSE_Tumbleweed
        paths:
          - target_project: openSUSE:Factory
            target_repository: snapshot
        architectures: [ x86_64 ]
      - name: '15.4'
        paths:
          - target_project: openSUSE:Tools
            target_repository: '15.4'
        architectures: [ x86_64 ]
  filters:
    event: pull_request0707010000000D000081A4000000000000000000000001638F17E500000044000000000000000000000000000000000000002E00000000sle-prjmgr-tools-1670322149.d38bfb5/.pylintrc[MASTER]
extension-pkg-whitelist=lxml

[FORMAT]
max-line-length=120
0707010000000E000081A4000000000000000000000001638F17E500000126000000000000000000000000000000000000003700000000sle-prjmgr-tools-1670322149.d38bfb5/CODE_OF_CONDUCT.md# Code of Conduct

The openSUSE Code of Conduct applies to this repository. It can be found at two places:

- in the openSUSE Wiki: <https://en.opensuse.org/Code_of_Conduct>
- or its canoncial version on code.opensuse.org: <https://code.opensuse.org/project/coc/blob/main/f/Code-of-Conduct.md>
0707010000000F000081A4000000000000000000000001638F17E500003687000000000000000000000000000000000000002C00000000sle-prjmgr-tools-1670322149.d38bfb5/LICENSEEUROPEAN UNION PUBLIC LICENCE v. 1.2 
EUPL © the European Union 2007, 2016

This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined below) which is provided under the 
terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such 
use is covered by a right of the copyright holder of the Work). 
The Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following 
notice immediately following the copyright notice for the Work: 
                          Licensed under the EUPL 
or has expressed by any other means his willingness to license under the EUPL.

1.Definitions 
In this Licence, the following terms have the following meaning: 
— ‘The Licence’:this Licence. 
— ‘The Original Work’:the work or software distributed or communicated by the Licensor under this Licence, available 
as Source Code and also as Executable Code as the case may be. 
— ‘Derivative Works’:the works or software that could be created by the Licensee, based upon the Original Work or 
modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work 
required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in 
the country mentioned in Article 15. 
— ‘The Work’:the Original Work or its Derivative Works. 
— ‘The Source Code’:the human-readable form of the Work which is the most convenient for people to study and 
modify. 
— ‘The Executable Code’:any code which has generally been compiled and which is meant to be interpreted by 
a computer as a program. 
— ‘The Licensor’:the natural or legal person that distributes or communicates the Work under the Licence. 
— ‘Contributor(s)’:any natural or legal person who modifies the Work under the Licence, or otherwise contributes to 
the creation of a Derivative Work. 
— ‘The Licensee’ or ‘You’:any natural or legal person who makes any usage of the Work under the terms of the 
Licence. 
— ‘Distribution’ or ‘Communication’:any act of selling, giving, lending, renting, distributing, communicating, 
transmitting, or otherwise making available, online or offline, copies of the Work or providing access to its essential 
functionalities at the disposal of any other natural or legal person.

2.Scope of the rights granted by the Licence 
The Licensor hereby grants You a worldwide, royalty-free, non-exclusive, sublicensable licence to do the following, for 
the duration of copyright vested in the Original Work: 
— use the Work in any circumstance and for all usage, 
— reproduce the Work, 
— modify the Work, and make Derivative Works based upon the Work, 
— communicate to the public, including the right to make available or display the Work or copies thereof to the public 
and perform publicly, as the case may be, the Work, 
— distribute the Work or copies thereof, 
— lend and rent the Work or copies thereof, 
— sublicense rights in the Work or copies thereof. 
Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the 
applicable law permits so. 
In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed 
by law in order to make effective the licence of the economic rights here above listed. 
The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to any patents held by the Licensor, to the 
extent necessary to make use of the rights granted on the Work under this Licence.

3.Communication of the Source Code 
The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as 
Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with 
each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to 
the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to 
distribute or communicate the Work.

4.Limitations on copyright 
Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the 
exclusive rights of the rights owners in the Work, of the exhaustion of those rights or of other applicable limitations 
thereto.

5.Obligations of the Licensee 
The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those 
obligations are the following:

Attribution right: The Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to 
the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the 
Licence with every copy of the Work he/she distributes or communicates. The Licensee must cause any Derivative Work 
to carry prominent notices stating that the Work has been modified and the date of modification.

Copyleft clause: If the Licensee distributes or communicates copies of the Original Works or Derivative Works, this 
Distribution or Communication will be done under the terms of this Licence or of a later version of this Licence unless 
the Original Work is expressly distributed only under this version of the Licence — for example by communicating 
‘EUPL v. 1.2 only’. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the 
Work or Derivative Work that alter or restrict the terms of the Licence.

Compatibility clause: If the Licensee Distributes or Communicates Derivative Works or copies thereof based upon both 
the Work and another work licensed under a Compatible Licence, this Distribution or Communication can be done 
under the terms of this Compatible Licence. For the sake of this clause, ‘Compatible Licence’ refers to the licences listed 
in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with 
his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail.

Provision of Source Code: When distributing or communicating copies of the Work, the Licensee will provide 
a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available 
for as long as the Licensee continues to distribute or communicate the Work. 
Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names 
of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and 
reproducing the content of the copyright notice.

6.Chain of Authorship 
The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or 
licensed to him/her and that he/she has the power and authority to grant the Licence. 
Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or 
licensed to him/her and that he/she has the power and authority to grant the Licence. 
Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions 
to the Work, under the terms of this Licence.

7.Disclaimer of Warranty 
The Work is a work in progress, which is continuously improved by numerous Contributors. It is not a finished work 
and may therefore contain defects or ‘bugs’ inherent to this type of development. 
For the above reason, the Work is provided under the Licence on an ‘as is’ basis and without warranties of any kind 
concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or 
errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this 
Licence. 
This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work.

8.Disclaimer of Liability 
Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be 
liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the 
Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss 
of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However, 
the Licensor will be liable under statutory product liability laws as far such laws apply to the Work.

9.Additional agreements 
While distributing the Work, You may choose to conclude an additional agreement, defining obligations or services 
consistent with this Licence. However, if accepting obligations, You may act only on your own behalf and on your sole 
responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify, 
defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by 
the fact You have accepted any warranty or additional liability.

10.Acceptance of the Licence 
The provisions of this Licence can be accepted by clicking on an icon ‘I agree’ placed under the bottom of a window 
displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of 
applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms 
and conditions. 
Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You 
by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution 
or Communication by You of the Work or copies thereof.

11.Information to the public 
In case of any Distribution or Communication of the Work by means of electronic communication by You (for example, 
by offering to download the Work from a remote location) the distribution channel or media (for example, a website) 
must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence 
and the way it may be accessible, concluded, stored and reproduced by the Licensee.

12.Termination of the Licence 
The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms 
of the Licence. 
Such a termination will not terminate the licences of any person who has received the Work from the Licensee under 
the Licence, provided such persons remain in full compliance with the Licence.

13.Miscellaneous 
Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the 
Work. 
If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or 
enforceability of the Licence as a whole. Such provision will be construed or reformed so as necessary to make it valid 
and enforceable. 
The European Commission may publish other linguistic versions or new versions of this Licence or updated versions of 
the Appendix, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence. 
New versions of the Licence will be published with a unique version number. 
All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take 
advantage of the linguistic version of their choice.

14.Jurisdiction 
Without prejudice to specific agreement between parties, 
— any litigation resulting from the interpretation of this License, arising between the European Union institutions, 
bodies, offices or agencies, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice 
of the European Union, as laid down in article 272 of the Treaty on the Functioning of the European Union, 
— any litigation arising between other parties and resulting from the interpretation of this License, will be subject to 
the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business.

15.Applicable Law 
Without prejudice to specific agreement between parties, 
— this Licence shall be governed by the law of the European Union Member State where the Licensor has his seat, 
resides or has his registered office, 
— this licence shall be governed by Belgian law if the Licensor has no seat, residence or registered office inside 
a European Union Member State.

Appendix

‘Compatible Licences’ according to Article 5 EUPL are: 
— GNU General Public License (GPL) v. 2, v. 3 
— GNU Affero General Public License (AGPL) v. 3 
— Open Software License (OSL) v. 2.1, v. 3.0 
— Eclipse Public License (EPL) v. 1.0 
— CeCILL v. 2.0, v. 2.1 
— Mozilla Public Licence (MPL) v. 2 
— GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3 
— Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for works other than software 
— European Union Public Licence (EUPL) v. 1.1, v. 1.2 
— Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong Reciprocity (LiLiQ-R+).

The European Commission may update this Appendix to later versions of the above licences without producing 
a new version of the EUPL, as long as they provide the rights granted in Article 2 of this Licence and protect the 
covered Source Code from exclusive appropriation. 
All other changes or additions to this Appendix require the production of a new EUPL version.

07070100000010000081A4000000000000000000000001638F17E5000003C4000000000000000000000000000000000000002D00000000sle-prjmgr-tools-1670322149.d38bfb5/Makefilebuild:
	python3 setup.py build

install:
	python3 setup.py install

sdist: build
	python3 setup.py sdist

rpm: sdist
	@mkdir -p rpm-build
	@cp dist/*.tar.gz rpm-build/
	rpmbuild \
	--define='_topdir %(pwd)/rpm-build' \
	--define='_builddir %{_topdir}' \
	--define='_rpmdir %{_topdir}' \
	--define='_srcrpmdir %{_topdir}' \
	--define='_specdir %{_topdir}' \
	--define='_rpmfilename %%{NAME}-%%{VERSION}-%%{RELEASE}.%%{ARCH}.rpm' \
	--define='_sourcedir  %{_topdir}' \
	-ba sle-prjmgr-tools.spec

clean:
	@rm -r rpm-build build dist *.egg-info

podman-rpm-builder:
	@podman build -f docker/build.dockerfile -t localhost/sle-prjmgr-tools-builder:latest .
	@podman run -it --rm -v $(CURDIR):/code localhost/sle-prjmgr-tools-builder:latest

podman-rpm-install-check:
	@podman build -f docker/install-check.dockerfile -t localhost/sle-prjmgr-tools-install-check:latest .
	@podman run -it --rm -v $(CURDIR)/rpm-build:/rpms localhost/sle-prjmgr-tools-install-check:latest
07070100000011000081A4000000000000000000000001638F17E500000335000000000000000000000000000000000000002E00000000sle-prjmgr-tools-1670322149.d38bfb5/README.md# sle-prjmgr-tools

This is a repository containing shared release management tools for SUSE. Tools are expected to be version agnostic,
release or version specific tools should be clearly documented.

## How to install & use

The preferred way are the RPMs.

You may install the tool via either:

- `zypper in sle-prjmgr-tools`
- `pip install sle-prjmgr-tools`
- `pip install git+https://github.com/openSUSE/sle-prjmgr-tools.git`
- or you install it from the locally built RPMs or via pip.

## Tool overview

For an overview see `sle-prjmgr-tools -h` or `sle-prjmgr-tools <tool_name> -h`.

## Archive of the old code

This repository has its root (before open-sourcing it) in the internal SUSE Gitlab. If you have access then you may
visit the history [here](https://gitlab.suse.de/sle-prjmgr/release-management-tools).
07070100000012000081A4000000000000000000000001638F17E500000185000000000000000000000000000000000000003000000000sle-prjmgr-tools-1670322149.d38bfb5/SECURITY.md# Security Policy

## Supported Versions

This project is a rolling release. Thus only the latest release is supported. If you find a security vulnerability in
an older version, please check that it applies to the current version.

## Reporting a Vulnerability

In case you find a valid vulnerability please contact the SUSE Security team at:
[security@suse.com](mailto:security@suse.com)
07070100000013000041ED000000000000000000000002638F17E500000000000000000000000000000000000000000000002B00000000sle-prjmgr-tools-1670322149.d38bfb5/docker07070100000014000081A4000000000000000000000001638F17E5000000E3000000000000000000000000000000000000003C00000000sle-prjmgr-tools-1670322149.d38bfb5/docker/build.dockerfileFROM registry.opensuse.org/opensuse/leap:15.4

RUN ["mkdir", "/code"]
RUN ["zypper", "in", "-y", "rpm-build", "python-rpm-macros", "python3-devel", "python3-setuptools"]

WORKDIR "/code"
VOLUME ["/code"]

CMD [ "make", "rpm" ]
07070100000015000081A4000000000000000000000001638F17E5000001F1000000000000000000000000000000000000004400000000sle-prjmgr-tools-1670322149.d38bfb5/docker/install-check.dockerfileFROM registry.opensuse.org/opensuse/leap:15.4

RUN [ \
    "zypper", \
    "in", \
    "-y", \
    "python3-requests", \
    "python3-PyYAML", \
    "python3-jira", \
    "python3-lxml", \
    "python3-importlib_resources", \
    "python3-keyring", \
    "osc" \
]

WORKDIR "/rpms"
VOLUME ["/rpms"]

# We don't know the exact name of the RPM. Thus we need a command line to expand the wildcard.
CMD ["/bin/sh", "-c", "zypper in -y --allow-unsigned-rpm *.rpm && echo '---' && sle-prjmgr-tools -h"]
07070100000016000081A4000000000000000000000001638F17E5000003BC000000000000000000000000000000000000002E00000000sle-prjmgr-tools-1670322149.d38bfb5/setup.cfg[metadata]
name = sle-prjmgr-tools
version = attr: sle_prjmgr_tools.__version__
description = SLE Project management tools to release SLE based products
long_description = file: README.md
long_description_content_type = text/markdown
keywords = SUSE
license = EUPL-1.2
classifiers =
    Programming Language :: Python :: 3
license_files = LICENSE
author = SUSE SLE Project Managers
project_urls =
    Source = https://github.com/openSUSE/sle-prjmgr-tools
    Tracker = https://github.com/openSUSE/sle-prjmgr-tools/issues

[options]
zip_safe = False
packages = find:
install_requires =
    requests
    PyYAML
    osc
    jira
    lxml
    keyring
    importlib_resources

[options.package_data]
sle_prjmgr_tools.config =
    *.json

[options.entry_points]
console_scripts =
    sle-prjmgr-tools = sle_prjmgr_tools.cli:main

[options.extras_require]
lint =
    black
    pylint
    mypy
    types-PyYAML
    types-requests
#    types-lxml
test =
    pytest
07070100000017000081A4000000000000000000000001638F17E500000045000000000000000000000000000000000000002D00000000sle-prjmgr-tools-1670322149.d38bfb5/setup.pyfrom setuptools import setup

if __name__ == "__main__":
 setup()
07070100000018000081A4000000000000000000000001638F17E5000000A2000000000000000000000000000000000000003D00000000sle-prjmgr-tools-1670322149.d38bfb5/sle-prjmgr-tools.changes-------------------------------------------------------------------
Tue Nov 29 12:55:04 UTC 2022 - Enno Gotthold <egotthold@suse.com>

- Initial version packaged
07070100000019000081A4000000000000000000000001638F17E50000065B000000000000000000000000000000000000003A00000000sle-prjmgr-tools-1670322149.d38bfb5/sle-prjmgr-tools.spec#
# spec file for package test
#
# Copyright (c) 2022 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
# upon. The license for this file, and modifications and additions to the
# file, is the same license as for the pristine package itself (unless the
# license for the pristine package is not an Open Source License, in which
# case the license is the MIT License). An "Open Source License" is a
# license that conforms to the Open Source Definition (Version 1.9)
# published by the Open Source Initiative.

# Please submit bugfixes or comments via https://bugs.opensuse.org/
#

%define sdist_name sle_prjmgr_tools

Name:           sle-prjmgr-tools
Version:        0.0.5
Release:        0
Summary:        SUSE SLE release management tools
License:        EUPL-1.2
URL:            https://github.com/openSUSE/sle-prjmgr-tools
Source:         %{name}-%{version}.tar.gz
BuildRequires:  python3-devel
BuildRequires:  python3-setuptools
BuildRequires:  python-rpm-macros
Requires:       python3-requests
Requires:       python3-importlib-resources
Requires:       python3-PyYAML
Requires:       python3-jira
Requires:       python3-lxml
Requires:       osc
Recommends:     python3-keyring

%description
SUSE SLE release management tools that help publish Service Packs and Snapshots.

%prep
%autosetup -n %{name}-%{version}

%build
%py3_build

%install
%py3_install

%post
%postun

%files
%license LICENSE
%doc README.md
%{_bindir}/%{name}
%{python3_sitelib}/%{sdist_name}/
%{python3_sitelib}/%{sdist_name}-*

%changelog
0707010000001A000041ED000000000000000000000002638F17E500000000000000000000000000000000000000000000002F00000000sle-prjmgr-tools-1670322149.d38bfb5/sle_common0707010000001B000081A4000000000000000000000001638F17E5000000AA000000000000000000000000000000000000003A00000000sle-prjmgr-tools-1670322149.d38bfb5/sle_common/.gitignore*.csv
*.xml
package-list.txt
retry.txt
*.list
packages-owned-by-locked-accounts.txt
update_projects.txt
updated_packages.txt
2020*
2021*
ChangeLog*
*-RPMs
coldpool-*.log
0707010000001C000081ED000000000000000000000001638F17E500000842000000000000000000000000000000000000003F00000000sle-prjmgr-tools-1670322149.d38bfb5/sle_common/diff-modules.sh#!/usr/bin/env sh

#set -x

THIS=$(basename $0)

function usage() {
 echo "
 Usage:
 $THIS -f <from_projec> [-o <from_revision_number>] -t <to_project> [-d <to_revision_number>] 
 ex: $THIS -f 15-SP2 -t 15-SP3 -d 75
 "
 exit -1
}

FROM_REVISION=''
TO_REVISION=''

while getopts "f:t:o:d:" opt; do
    case $opt in
        f)
            FROM=SUSE:SLE-$OPTARG:GA
            ;;
        t)
            TO=SUSE:SLE-$OPTARG:GA
            ;;
        o)
            FROM_REVISION="-r $OPTARG"
            ;;
        d)
            TO_REVISION="-r $OPTARG"
    esac
done

[ -z "${FROM}" -o -z "${TO}" ] && usage

FROM_GROUPS_FILE="groups_FROM.yml"
TO_GROUPS_FILE="groups_TO.yml"
CHANGES_GROUPS_FILE="Changes_from_${FROM}_to_${TO}.diff"

osc -A https://api.suse.de/ checkout ${FROM} 000package-groups groups.yml ${FROM_REVISION}
mv -v groups.yml ${FROM_GROUPS_FILE}
osc -A https://api.suse.de/ checkout ${TO} 000package-groups groups.yml ${TO_REVISION}
mv -v groups.yml ${TO_GROUPS_FILE}

# remove the JIRA, bug references and commented lines
sed -i -e 's/\s*#.*$//' ${FROM_GROUPS_FILE}
sed -i -e 's/\s*#.*$//' ${TO_GROUPS_FILE}

# marked the modules in ${TO_GROUPS_FILE} to make difference
sed -i -e 's/$^[a-zA-Z_]*:$$/ \1/g' ${TO_GROUPS_FILE}

diff --suppress-common-lines --ignore-blank-lines --ignore-trailing-space ${FROM_GROUPS_FILE} ${TO_GROUPS_FILE} > ${CHANGES_GROUPS_FILE}

rm -vf ${FROM_GROUPS_FILE}
rm -vf ${TO_GROUPS_FILE}

# remove the line numbers
sed -i -e '/^[0-9].*$/d' ${CHANGES_GROUPS_FILE}

# remove ---
sed -i -e '/^---$/d' ${CHANGES_GROUPS_FILE}

# remove the repetitions in module names
sed -i -e '/< [a-zA-Z_]*:$/d' ${CHANGES_GROUPS_FILE}

# remove the empty lines
sed -i -e '/^[<>]\s*$/d' ${CHANGES_GROUPS_FILE}

# mark removed packages with -
sed -i -e 's/^<\s*-/- /' ${CHANGES_GROUPS_FILE}

# mark added packages with +
sed -i -e 's/^>\s*-/+  /' ${CHANGES_GROUPS_FILE}

# mark removed from module names
sed -i -e 's/^[<>]\s\s//' ${CHANGES_GROUPS_FILE}

# remove lines not related with modules
sed -i '/^UNWANTED:/,$!d' ${CHANGES_GROUPS_FILE}

echo ${CHANGES_GROUPS_FILE}
0707010000001D000081ED000000000000000000000001638F17E5000014E1000000000000000000000000000000000000004E00000000sle-prjmgr-tools-1670322149.d38bfb5/sle_common/package-updates-from-xcdchk.sh#!/bin/sh

if [ $# -lt 2 ]; then
       echo "usage : package-updates-from-xcdchk.sh Build1 Build2  [SLE-xx-SPy] [ORIGIN_VERSION as SLE-xx-SPz]"
       exit 1
fi

BUILD1=${1/#Build/}
BUILD2=${2/#Build/}
VERSION=${3:-SLE-15-SP5}
ORIGIN_VERSION=${4:-SLE-15-SP5}

[ -r ChangeLog-$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2 ] || wget http://xcdchk.suse.de/raw/$VERSION-Full-Test/$BUILD2/all/ChangeLog-$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2  > /dev/null
[ -r $ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-updated-RPMs ] || wget http://xcdchk.suse.de/raw/$VERSION-Full-Test/$BUILD2/all/$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-updated-RPMs > /dev/null
[ -r $ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-new-RPMs ] || wget http://xcdchk.suse.de/raw/$VERSION-Full-Test/$BUILD2/all/$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-new-RPMs > /dev/null 
[ -r $ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-missing-RPMs ] || wget http://xcdchk.suse.de/raw/$VERSION-Full-Test/$BUILD2/all/$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-missing-RPMs > /dev/null
[ -r $ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-downgraded-RPMs ] || wget http://xcdchk.suse.de/raw/$VERSION-Full-Test/$BUILD2/all/$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-downgraded-RPMs > /dev/null

echo "Updated packages: "
grep "^o Update" ChangeLog-$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2 | awk '{print $3}' | while read -r line; do grep "^$line\." $ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-updated-RPMs; done | sed 's/\..*:/:/' | sed 's/^/\* /' | uniq
grep "^o Added" ChangeLog-$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2 | awk '{print $3}' | while read -r line; do grep "^$line\." $ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-updated-RPMs; done | sed 's/\..*:/:/' | sed 's/^/\* /' | uniq

echo
echo "Added packages: "
grep "^o Added" ChangeLog-$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2 | awk '{print $3}' | while read -r line; do grep ^$line $ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-new-RPMs; done | sed -e 's/$.*$-$[^-]*$\-$[^-]*$\..*/\1 \2-\3/' | sed 's/^/\* /' | uniq
grep "^o Update" ChangeLog-$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2 | awk '{print $3}' | while read -r line; do grep ^$line $ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-new-RPMs; done | sed -e 's/$.*$-$[^-]*$\-$[^-]*$\..*/\1 \2-\3/' | sed 's/^/\* /' | uniq

echo
echo "Downgraded packages: "
cat $ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2-downgraded-RPMs | sed 's/\..*:/:/' | sed 's/^/\* /' | uniq

echo
echo "Mentioned bug references: "
cat ChangeLog-$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2 | while read -r line; do egrep -o '[bsc#|bnc#|boo#][0-9]{7}'; done | uniq | while read -r line; do egrep -o '[0-9]{7}'; done | sort | paste -s -d, -

echo
echo "Mentioned JIRA references: "
cat ChangeLog-$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2 | egrep -o 'jsc#SLE-[0-9]{5}|jsc#PED-[0-9]{1,5}' | sort | uniq | paste -s -d, -

PED=$(cat ChangeLog-$ORIGIN_VERSION-Full-Test-Build$BUILD1-Build$BUILD2 | egrep -o 'PED-[0-9]{1,5}' | sort | uniq | paste -s -d, -)

echo
echo "JIRA query for incorrect state"
echo "=============================="
echo "Query:"
echo "------"
echo "issue in (${PED}) AND status NOT IN (\"QE Open\",\"QE In Progress\",\"QE Blocked\",\"Engineering Done\",\"Dev In Progress\",\"IBS Integration\") AND type = Implementation"
echo "Comment:"
echo "--------"
echo "A submit request referencing this feature has been merged into build${BUILD2}."
echo "Please update the state of this ticket, as it doesn't reflect the correct state of development."
echo "Labels:"
echo "-------"
echo "Add status:wait_for_status"
echo "Add status:code_merged"

echo
echo "JIRA query for still under development"
echo "======================================"
echo "Query:"
echo "------"
echo "issue in (${PED}) AND status = \"Dev In Progress\" AND type = Implementation"
echo "Comment:"
echo "--------"
echo "A submit request referencing this feature has been merged into build${BUILD2}."
echo "Labels:"
echo "-------"
echo "Remove status:wait_for_status"
echo "Add status:code_merged"

echo
echo "JIRA query for already completed features"
echo "========================================="
echo "Query:"
echo "------"
echo "issue in (${PED}) AND status IN (\"QE Open\",\"QE In Progress\",\"QE Blocked\",\"Engineering Done\") AND type = Implementation"
echo "Comment:"
echo "--------"
echo "A submit request referencing this feature has been merged into build${BUILD2}."
echo "Labels:"
echo "-------"
echo "no handling required, only remove stale \"status:\" labels"

echo
echo "JIRA query for features ready to transition"
echo "==========================================="
echo "Query:"
echo "------"
echo "issue in (${PED}) AND status \"IBS Integration\" AND type = Implementation"
echo "Comment:"
echo "--------"
echo "A submit request referencing this feature has been merged into build${BUILD2}."
echo "Labels:"
echo "-------"
echo "Remove status:code_merged"
echo "Remove status:wait_for_status"
0707010000001E000041ED000000000000000000000004638F17E500000000000000000000000000000000000000000000003500000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools0707010000001F000081A4000000000000000000000001638F17E500000059000000000000000000000000000000000000004100000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/__init__.py"""
Main module of the project. Defines only the version atm.
"""

__version__ = "0.0.5"
07070100000020000081A4000000000000000000000001638F17E500000F24000000000000000000000000000000000000003C00000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/cli.py"""
This is the wrapper script that specifies the CLI entry point that can load the scripts from a config file.

The config file has the following format: { "modules": [ "module1", "module2" ] }

Valid locations for the configuration file are:

- "/etc/sle-prjmgr-tools.json"
- "$XDG_CONFIG_HOME/sle-prjmgr-tools.json"
- "$RELEASE_MANAGEMENT_TOOLS_FILE"

A module must have a "build_parser" method that takes a single argument. The method is responsible to assign with
"set_default" the func kwarg. The CLI entrypoint is called "main_cli" and has a single arguments that is an argparse
namespace. This should be just a wrapper to the "main" function that has the actual arguments defined.

If no config is supplied the built-in configuration is used.

Example usage of the CLI for development (from git project root):

> . venv/bin/activate
  > export RELEASE_MANAGEMENT_TOOLS_FILE="config/sle-prjmgr-tools.json"
  > python3 -m sle_prjmgr_tools.cli -h
"""
import argparse
import importlib
import json
import logging
import os
import traceback
from typing import List

from importlib_resources import files

CONFIG_LOCATIONS = [
    "/etc/sle-prjmgr-tools.json",
    "$XDG_CONFIG_HOME/sle-prjmgr-tools.json",
    "$RELEASE_MANAGEMENT_TOOLS_FILE",
]
PARSER = argparse.ArgumentParser(prog="sle_prjmgr_tools")
PARSER.add_argument(
    "--osc-config",
    dest="osc_config",
    help="The location of the oscrc if a specific one should be used.",
)
PARSER.add_argument(
    "--osc-instance",
    dest="osc_instance",
    help="The URL of the API from the Open Buildservice instance that should be used.",
    default="https://api.suse.de",
)
PARSER.add_argument(
    "--jira-instance",
    dest="jira_instance",
    help="The URL for the JIRA instance.",
    default="https://jira.suse.com",
)
PARSER.add_argument(
    "--confluence-instance",
    dest="confluence_instance",
    help="The URL for the Confluence instance.",
    default="https://confluence.suse.com",
)
SUBPARSERS = PARSER.add_subparsers(help="Help for the actual scripts")
logger = logging.getLogger()

def load_config(path: str) -> List[str]:
    """
    Loads the JSON config file.

:param path: This path is excepted to exist. It should be the absolute path to the config file.
    :return: The list of modules that should be loaded.
    """
    with open(path, "rt", encoding="UTF-8") as json_fp:
        try:
            json_dict = json.load(json_fp)
            logger.debug('JSON config loaded from "%s".', path)
            return json_dict.get("modules")
        except json.JSONDecodeError:
            logger.debug("JSON syntax error! Fix syntax to load modules.")
            traceback.print_exc()
            return []

def import_plugin(name: str):
    """
    This method imports a plugin

:param name: The name of the module in the "sle_prjmgr_tools" module.
    """
    plugin = importlib.import_module(f".{name}", package="sle_prjmgr_tools")
    plugin.build_parser(SUBPARSERS)

def main():
    """
    The main entrypoint for the library.
    """
    module_list = []
    config_found = False
    for location in CONFIG_LOCATIONS:
        if "$" in location:
            real_location = os.path.expandvars(location)
        else:
            real_location = location
        if os.path.isfile(real_location):
            module_list = load_config(real_location)
            config_found = True
        else:
            logger.debug('"%s" was skipped.', real_location)
    if not config_found:
        backup_config_path = str(
            files("sle_prjmgr_tools.config").joinpath("sle-prjmgr-tools.json")
        )
        module_list = load_config(backup_config_path)
        logger.debug("Built-In Configuration was used!")
    for module in module_list:
        import_plugin(module)
    args = PARSER.parse_args()
    args.func(args)

if __name__ == "__main__":
    main()
07070100000021000041ED000000000000000000000002638F17E500000000000000000000000000000000000000000000003C00000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/config07070100000022000081A4000000000000000000000001638F17E500000027000000000000000000000000000000000000004800000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/config/__init__.py"""
Configuration related package.
"""
07070100000023000081A4000000000000000000000001638F17E5000000C9000000000000000000000000000000000000005200000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/config/sle-prjmgr-tools.json{
  "modules": [
    "update_build_status_page",
    "incident_repos",
    "packagelist_report",
    "search_binary",
    "list_accepted_pkgs",
    "jira_epics",
    "sle_build",
    "release_to"
  ]
}07070100000024000081A4000000000000000000000001638F17E500000000000000000000000000000000000000000000004500000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/diff_modules.py07070100000025000081A4000000000000000000000001638F17E500000961000000000000000000000000000000000000004700000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/incident_repos.py"""
This script retrieves all repositories for each incident it is given. The datasource is the SUSE internal SMELT tool.
"""

from typing import List

import requests

QUERY = """
query {{
  incidents(incidentId:{}) {{
    edges {{
      node {{
        repositories {{
          edges {{
            node {{
              name
            }}
          }}
        }}
      }}
    }}
  }}
}}
"""

def build_parser(parent_parser):
    """
    Builds the parser for this script. This is executed by the main CLI dynamically.

:param parent_parser: The subparsers object from argparse.
    """
    subparser = parent_parser.add_parser("incident_repos", help="incident_repos help")
    subparser.add_argument(
        "--smelt-api",
        dest="smelt_api",
        help="URL to the SMELT API.",
        default="https://smelt.suse.de/graphql/",
    )
    subparser.add_argument(
        "incidents",
        metavar="incident",
        help="The incident numbers",
        nargs="+",
        type=int,
    )
    subparser.set_defaults(func=main_cli)

def get_incident_repos(smelt_api_url: str, iid: int, timeout=180):
    """
    Retrieve all repositories that are affected by a single incident.

:param smelt_api_url: The URL where the SMELT GraphQL API is present.
    :param iid: The incident ID.
    :param timeout: The timeout that is used for the SMELT API.
    :return: The set of repositories that is affected.
    """
    query = {"query": QUERY.format(iid)}
    results = requests.post(smelt_api_url, query, timeout=timeout).json()

incs_repos = [
        i["node"]["repositories"]["edges"]
        for i in results["data"]["incidents"]["edges"]
    ]
    repos = set()
    for inc_repos in incs_repos:
        repos.update({s["node"]["name"] for s in inc_repos})

return repos

def main(smelt_api_url: str, incidents: List[int]):
    """
    Main routine executes the non-CLI related logic.

:param smelt_api_url: The URL where the SMELT GraphQL API is present.
    :param incidents: The list of incidents that should be looked up.
    """
    for iid in incidents:
        print(f"{iid}:")
        for repo in get_incident_repos(smelt_api_url, iid):
            print(f"  * {repo}")

def main_cli(args):
    """
    Main routine that executes the script

:param args: Argparse Namespace that has all the arguments
    """
    main(args.smelt_api, args.incidents)
07070100000026000081A4000000000000000000000001638F17E5000010A3000000000000000000000000000000000000004300000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/jira_epics.py"""
Get all JIRA Issues that are mentioned in the changelog of a project.
"""
import re
from typing import Dict, List

from lxml import etree
from osc import core, conf  # type: ignore

def build_parser(parent_parser):
    """
    Builds the parser for this script. This is executed by the main CLI dynamically.

:param parent_parser: The subparsers object from argparse.
    """
    subparser = parent_parser.add_parser("jira_epics", help="jira_epics help")
    subparser.add_argument(
        "--target",
        "-t",
        dest="target",
        default="SUSE:SLE-15-SP5:GA",
        help="Project to execute against.",
    )
    subparser.set_defaults(func=main_cli)

def osc_prepare():
    """
    This has to be executed to the ini-style config is converted into their corresponding types.
    """
    conf.get_config()

def osc_packages_exclude_000(apiurl: str, target: str) -> List[str]:
    """
    Retrieve a list of packages for a given project where all packages starting with ``000`` are being excluded.

:param apiurl: URL where the API from the build-service can be reached.
    :param target: The target project to search.
    :return: The list of packages in the project.
    """
    result = []
    for package in core.meta_get_packagelist(apiurl, target):
        if not package.startswith("000"):
            result.append(package)
    return result

def get_issue_list(apiurl: str, target: str, package: str) -> List[str]:
    """
    Scans the changelog for a specific package for jsc mentions.

:param apiurl: URL where the API from the build-service can be reached.
    :param target: The target project that this is checked against.
    :param package: The package that should be scanned for issues.
    :return: The list of issues that could be found.
    """
    baseurl = ["source", target, package]
    query = {"cmd": "diff", "view": "xml", "onlyissues": "1", "orev": "1"}
    url = core.makeurl(apiurl, baseurl, query)
    fp_post_result = core.http_POST(url)
    xml_issues = etree.parse(fp_post_result).getroot()
    issue_list_xml = xml_issues.xpath(
        '//sourcediff/issues/issue[@state="added"][@tracker="jsc"]'
    )
    issue_list = []
    for issue in issue_list_xml:
        issue_list.append(issue.get("label"))
    return issue_list

def scan_commitlog_for_issues(apiurl: str, target: str, package: str) -> List[str]:
    """
    Scans the commitlog for a specific package for jsc mentions.

:param apiurl: URL where the API from the build-service can be reached.
    :param target: The target project that this is checked against.
    :param package: The package that should be scanned for issues.
    :return: The list of issues that could be found.
    """
    issue_list = []
    jsc_regex = re.compile(r"jsc#[a-zA-Z]*-\d*")
    xml_str_commitlog = "\n".join(
        core.get_commitlog(
            apiurl, target, package, None, format="xml", revision_upper=None
        )
    )
    tree = etree.fromstring(xml_str_commitlog)
    msgs = tree.xpath("//msg")
    for msg in msgs:
        matches = jsc_regex.findall(msg.text)
        if len(matches) > 0:
            issue_list.extend(matches)
    return issue_list

def main(
    apiurl="https://api.suse.de", target="SUSE:SLE-15-SP3:GA"
) -> Dict[str, List[str]]:
    """
    Main routine executes the non-CLI related logic.

:param apiurl: URL where the API from the build-service can be reached.
    :param target: The target project that this is checked against.
    """
    osc_prepare()
    result: Dict[str, List[str]] = {}
    for package in osc_packages_exclude_000(apiurl, target):
        issue_list = get_issue_list(apiurl, target, package)
        issue_list.extend(scan_commitlog_for_issues(apiurl, target, package))
        result[package] = issue_list
    return result

def main_cli(args):
    """
    Main routine that executes the script

:param args: Argparse Namespace that has all the arguments
    """
    data = main(apiurl=args.osc_instance, target=args.target)
    for package, issue_list in data.items():
        if len(issue_list) > 0:
            print(package)
            for issue in issue_list:
                print(issue)
        else:
            print(f"{package} - No jscs mentioned")
07070100000027000081A4000000000000000000000001638F17E500001200000000000000000000000000000000000000004B00000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/list_accepted_pkgs.py"""
Module to list all accepted SRs that are accepted that changed, added or removed a package.
"""
import time
from typing import Optional, Tuple

from osc import conf, core  # type: ignore

def build_parser(parent_parser):
    """
    Builds the parser for this script. This is executed by the main CLI dynamically.

:return: The subparsers object from argparse.
    """
    subparser = parent_parser.add_parser(
        "list_accepted_pkgs", help="list_accepted_pkgs help"
    )
    subparser.add_argument("--project", "-p", dest="project", type=str, required=True)
    subparser.add_argument("--days", "-d", dest="time_range", type=int)
    subparser.set_defaults(func=main_cli)

def osc_prepare(osc_config: Optional[str] = None, osc_server: Optional[str] = None):
    """
    This has to be executed to the ini-style config is converted into their corresponding types.

:param osc_config: Path to the configuration file for osc. The default delegates the task to the osc library.
    :param osc_server: Server URL that points to the OBS server API.
    """
    conf.get_config(override_conffile=osc_config, override_apiurl=osc_server)

def osc_get_submit_requests(project: str):
    """
    Looks in the IBS the list of requests up that are accepted and submitted.

:param project: The project that should be checked.
    :return: The list of requests objects that are found with the state accepted and that are submitted.
    """
    return core.get_review_list(
        "https://api.suse.de", project=project, states=("accepted"), req_type="submit"
    )

def osc_get_delete_requests(project: str):
    """
    Looks in the IBS the list of requests up that are accepted and that delete a package.

:param project: The project that should be checked.
    :return: The list of requests objects that are found with the state accepted and that are deleting a package.
    """
    return core.get_review_list(
        "https://api.suse.de", project=project, states=("accepted"), req_type="delete"
    )

def filter_requests(days: int, requests) -> list:
    """
    Filter a given list by its date. The time of days is respected and not rounded. A request that was submitted at
    2pm on the earliest days that is included would be ignored if it is 3pm during execution of this method.

:param days: The days that should be filtered
    :param requests: The list with the requests to filter.
    :return: Filter list where every request is younger than the days specified.
    """
    result = []
    earliest_date = time.strftime(
        "%Y-%m-%dT%H:%M:%S", time.localtime(time.time() - days * 24 * 3600)
    )
    for request in requests:
        if request.state.when > earliest_date:
            result.append(request)
    return result

def main_cli(args):
    """
    Main routine that executes the script

:param args: Argparse Namespace that has all the arguments
    """
    # Parse arguments
    submit_requests, delete_requests = main(
        args.osc_instance, args.project, args.time_range
    )
    # Print both retrieved lists with format: "pkg-name (YYYY-MM-DDThh:mm:ss) hyperlink-to-request"
    print("==============================")
    print("SUBMIT REQUESTS")
    print("==============================")
    for request in submit_requests:
        print(
            f"{request.actions[0].src_package} ({request.state.when}) https://api.suse.de/{request.reqid}"
        )
    print("==============================")
    print("DELETE REQUESTS")
    print("==============================")
    for request in delete_requests:
        print(
            f"{request.actions[0].src_package} ({request.state.when}) https://api.suse.de/{request.reqid}"
        )

def main(apiurl: str, project: str, time_range: int) -> Tuple[list, list]:
    """
    Main routine executes the non-CLI related logic.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project that should be queried.
    :param time_range: The list of days that present the delimiter for the filter
    :return: A Tuple with the list of requests
    """
    # Prepare osc -> Config is ini style and needs to be converted first
    osc_prepare(osc_server=apiurl)
    # Retrieve SRs
    submit_requests = osc_get_submit_requests(project)
    # Retrieve SRs with delete requests
    delete_requests = osc_get_delete_requests(project)
    # Filter requests by days
    submit_requests = filter_requests(time_range, submit_requests)
    delete_requests = filter_requests(time_range, delete_requests)
    return submit_requests, delete_requests
07070100000028000081A4000000000000000000000001638F17E500000000000000000000000000000000000000000000005400000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/package_updates_from_xcdchk.py07070100000029000081A4000000000000000000000001638F17E5000030CE000000000000000000000000000000000000004B00000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/packagelist_report.py"""
This script calculates a diff between two project revisions and writes its output to a file where the added, moved and
removed packages are named.
"""

import logging
import shlex
import subprocess
import sys
import textwrap
from typing import Dict, List, Optional

import yaml

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

def build_parser(parent_parser):
    """
    Builds the parser for this script. This is executed by the main CLI dynamically.

:param parent_parser: The subparsers object from argparse.
    """
    subparser = parent_parser.add_parser(
        "packagelist_report", help="Report of package movements between 2 projects"
    )
    subparser.add_argument(
        "-f", "--from-project", type=str, help="Origin project", required=True
    )
    subparser.add_argument(
        "-t", "--to-project", type=str, help="Target project", required=True
    )
    subparser.add_argument(
        "--from-revision-number", type=str, help="Origin revision number"
    )
    subparser.add_argument(
        "--to-revision-number", type=str, help="Target revision number"
    )
    subparser.set_defaults(func=main_cli)

def convert_txt_to_dict(file_content: str) -> Dict[str, List[str]]:
    """
    Converts the text file downloaded and parses

:param file_content: The string that should be split
    :return: The dictionary with the package names as key and the list of groups they are in as a list.
    """
    ret: Dict[str, List[str]] = {}
    for line in file_content.splitlines():
        pkg, group = line.strip().split(":")
        ret.setdefault(pkg, [])
        ret[pkg].append(group)
    return ret

def convert_yml_to_dict(file_content: str, unsorted=False) -> Dict[str, List[str]]:
    """
    Loads the file content as a YAML file and then parses it according to the expected file structure.

:param file_content: The content of the YAML file.
    :param unsorted: If the package should be added to unsorted or not explicitly.
    :return: The dictionary with the package names as key and the list of groups they are in as a list.
    """
    ret: Dict[str, List[str]] = {}
    try:
        parsed_yaml = yaml.safe_load(file_content)
        for module, packages in parsed_yaml.items():
            for package in packages:
                if unsorted:
                    ret[package] = ["unsorted"]
                else:
                    ret[package] = [module]
    except yaml.YAMLError as yaml_error:
        logger.error(yaml_error, exc_info=True)
    return ret

def download_file(cmd: str):
    """
    Takes an osc command returns the stdout.

:param cmd: The osc command to run.
    :return: The stdout output.
    """
    logger.debug("Executing: %s", cmd)
    cmd_args = shlex.split(cmd)
    output = subprocess.run(cmd_args, capture_output=True, text=True, check=False)
    if output.returncode != 0:
        logger.warning("Failed to execute: %s", cmd)
        logger.warning(output.stderr)
    return output

def get_yml_files(command: str, revision) -> Optional[Dict[str, List[str]]]:
    """
    Retrieve the different reference YAML files and parse them.

:param command: The pre-built command that should be used.
    :param revision: The project revision to get the file from.
    :return: The dictionary with the package names as key and the list of groups they are in as a list.
    """
    ret: Dict[str, List[str]] = {}
    yaml_files = ["reference-summary.yml", "reference-unsorted.yml", "unneeded.yml"]
    for file in yaml_files:
        cmd = command + f" {file}"
        if revision:
            cmd += f" -r {revision}"
        output = download_file(cmd)
        if output.returncode != 0:
            return None
        unsorted_flag = file != yaml_files[0]
        content = convert_yml_to_dict(output.stdout, unsorted_flag)
        ret = {**ret, **content}
    return ret

def get_txt_file(cmd: str, revision) -> Optional[Dict[str, List[str]]]:
    """
    Retrieve and parse the content of ``summary-staging.txt``.

:param cmd: The pre-built command that should be used.
    :param revision: The project revision to get the file from.
    :return: The file that has been downloaded by osc and then parsed by ``convert_txt_to_dict()``.
    """
    file = "summary-staging.txt"
    cmd += f" {file}"
    if revision:
        cmd += f" -r {revision}"
    output = download_file(cmd)
    if output.returncode != 0:
        return None
    return convert_txt_to_dict(output.stdout)

def get_file_content(project: str, revision: str):
    """
    Retrieves the file content of a text file from 000package-groups.

:param project: The project that should be checked.
    :param revision: The project revision to get the file from.
    :return: The
    """
    apiurl = "https://api.suse.de/"
    package = "000package-groups"
    cmd = f"osc -A {apiurl} cat {project} {package}"
    ret = get_txt_file(cmd, revision)
    if not ret:
        ret = get_yml_files(cmd, revision)
        if not ret:
            sys.exit(1)
    write_summary_dict(project, ret)
    return ret

def read_yaml_file(file, unsorted=False):
    """
    Loads the file content as a YAML file and then parses it according to the expected file structure.

:param file: The content of the YAML file.
    :param unsorted: If the package should be added to unsorted or not explicitly.
    :return: The dictionary with the package names as key and the list of groups they are in as a list.
    """
    ret = {}
    with open(file, "r", encoding="UTF-8") as stream:
        try:
            parsed_yaml = yaml.safe_load(stream)
            for module, packages in parsed_yaml.items():
                for package in packages:
                    if unsorted:
                        ret[package] = ["unsorted"]
                    else:
                        ret[package] = [module]
        except yaml.YAMLError as yaml_error:
            logger.error(yaml_error, exc_info=True)
    return ret

def read_summary_file(file: str) -> Dict[str, List[str]]:
    """
    Reads a file and interprets it in the format of ``summary-staging.txt``.

:param file: The path to the file.
    :return: The dict with the package names as keys and the list of groups as a value.
    """
    ret: Dict[str, List[str]] = {}
    with open(file, "r", encoding="UTF-8") as fp_summary_file:
        for line in fp_summary_file:
            pkg, group = line.strip().split(":")
            ret.setdefault(pkg, [])
            ret[pkg].append(group)
    return ret

def write_summary_file(file: str, content: str) -> None:
    """
    Write a file to disk with the given content.

:param file: The file path of the desired target.
    :param content: The content to write.
    """
    logger.info("Summary report saved in %s", file)
    with open(file, "w", encoding="UTF-8") as fp_summary_file:
        fp_summary_file.write(content)

def write_summary_dict(file: str, content: Dict[str, List[str]]) -> None:
    """
    Write a file to disk with the given content.

:param file: The file path of the desired target.
    :param content: The dict with the packages as keys and their categories as value.
    """
    logger.info("List of %s packages saved in %s", file, file)
    output = []
    for pkg in sorted(content):
        for group in sorted(content[pkg]):
            output.append(f"{pkg}:{group}")

with open(file, "w", encoding="UTF-8") as fp_summary_file:
        for line in sorted(output):
            fp_summary_file.write(line + "\n")

def generate_package_diff_report(added: dict, moved: dict, removed: dict) -> str:
    """
    Generates the report with the help of the presorted dictionaries.

:param added: The dict with added packages
    :param moved: The dict with moved packages
    :param removed: The dict with removed packages
    :return: The str with the generated report. Newlines for formatting are present.
    """
    report = ""
    for removed_package in sorted(removed.keys()):
        report += f"**Remove from {removed_package}**\n\n```\n"
        paragraph = ", ".join(removed[removed_package])
        report += "\n".join(
            textwrap.wrap(
                paragraph, width=90, break_long_words=False, break_on_hyphens=False
            )
        )
        report += "\n```\n\n"

for move in sorted(moved.keys()):
        report += f"**Move from {move}**\n\n```\n"
        paragraph = ", ".join(moved[move])
        report += "\n".join(
            textwrap.wrap(
                paragraph, width=90, break_long_words=False, break_on_hyphens=False
            )
        )
        report += "\n```\n\n"

for group in sorted(added):
        report += f"**Add to {group}**\n\n```\n"
        paragraph = ", ".join(added[group])
        report += "\n".join(
            textwrap.wrap(
                paragraph, width=90, break_long_words=False, break_on_hyphens=False
            )
        )
        report += "\n```\n\n"

return report.strip()

def calculcate_package_diff(old_file: dict, new_file: dict) -> Optional[str]:
    """
    Calculate the package diff between the two dictionaries that were passed.

:param old_file: Dictionary with the content from the source project.
    :param new_file: Dictionary with the content from the target project.
    :return: The str with the generated report. As generated by ``generate_package_diff_report()``.
    """
    # remove common part
    keys = list(old_file.keys())
    for key in keys:
        if new_file.get(key, []) == old_file[key]:
            del new_file[key]
            del old_file[key]

if not old_file and not new_file:
        return None

added: Dict[str, List[str]] = {}
    for pkg in new_file:
        if pkg in old_file:
            continue
        addkey = ",".join(new_file[pkg])
        added.setdefault(addkey, [])
        added[addkey].append(pkg)

removed: Dict[str, List[str]] = {}
    for pkg in old_file:
        old_groups = old_file[pkg]
        if new_file.get(pkg):
            continue
        removekey = ",".join(old_groups)
        removed.setdefault(removekey, [])
        removed[removekey].append(pkg)

moved: Dict[str, List[str]] = {}
    for pkg in old_file:
        old_groups = old_file[pkg]
        new_groups = new_file.get(pkg)
        if not new_groups:
            continue
        movekey = ",".join(old_groups) + " to " + ",".join(new_groups)
        moved.setdefault(movekey, [])
        moved[movekey].append(pkg)

return generate_package_diff_report(added, moved, removed)

def main(
    from_project: str,
    from_revision_number: str,
    to_project: str,
    to_revision_number: str,
):
    """
    Main routine executes the non-CLI related logic.

:param from_project: Source project that should be used as a base.
    :param from_revision_number: Project revision number.
    :param to_project: Source project that should be used as a comparison target.
    :param to_revision_number: Project revision number.
    """
    from_summary = get_file_content(from_project, from_revision_number)
    to_summary = get_file_content(to_project, to_revision_number)
    report = calculcate_package_diff(from_summary, to_summary)
    # logger.debug(f"\n{report}")
    logger.debug("\n%s", from_revision_number)
    logger.debug("\n%s", to_revision_number)
    if report:
        summary_file = "summary-report.md"
        write_summary_file(summary_file, report)
    else:
        logger.info("No package movement reported")

# if os.path.isfile(reference_summary):
    # from_shipped = read_yaml_file(f'FROM-shipped.yml')
    # from_unsorted = read_yaml_file(f'FROM-unsorted.yml',True)
    # from_summary = {**from_shipped, **from_unsorted}
    # from_summary_file = f'from_summary-external'
    # write_summary_dict(from_summary_file, from_summary)

# to_summary = read_summary_file(f'TO-summary-staging.txt')
    # to_summary_file = f'to_summary-external'
    # write_summary_dict(to_summary_file, to_summary)

# report = calculcate_package_diff(from_summary, to_summary)
    # logger.debug(f"\n{report}")
    # summary_file = f'diff-report-external.md'
    # write_summary_file(summary_file, report)

def main_cli(args):
    """
    Main routine that executes the script

:param args: Argparse Namespace that has all the arguments
    """
    main(
        args.from_project,
        args.from_revision_number,
        args.to_project,
        args.to_revision_number,
    )
0707010000002A000081A4000000000000000000000001638F17E5000008C7000000000000000000000000000000000000004300000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/release_to.py"""
Module that will release a ``:GA`` project to ``:GA:TEST`` or ``GA:PUBLISH``.
"""
import enum
from typing import Optional

from sle_prjmgr_tools.utils.osc import OscReleaseHelper

class ReleaseTargets(enum.Enum):
    """
    This Enum contains all possible release targets for this script.
    """

TEST = 0
    PUBLISH = 1

def build_parser(parent_parser):
    """
    Builds the parser for this script. This is executed by the main CLI dynamically.

:param parent_parser: The subparsers object from argparse.
    """
    # pylint: disable=R0801
    subparser = parent_parser.add_parser("release_to", help="release_to help")
    group = subparser.add_mutually_exclusive_group(required=True)
    group.add_argument(
        "--test",
        dest="release_target",
        action="store_const",
        const=ReleaseTargets.TEST,
        help="If this flag is given, a release to :GA:TEST is triggered.",
    )
    group.add_argument(
        "--publish",
        dest="release_target",
        action="store_const",
        const=ReleaseTargets.PUBLISH,
        help="If this flag is given, a release to :GA:PUBLISH is triggered.",
    )
    subparser.add_argument(
        "project",
        metavar="project",
        help="Project that should be released including the GA suffix.",
    )

def main(
    obs_url: str, project: str, target: ReleaseTargets, osc_config: Optional[str] = None
):
    """
    Main routine executes the non-CLI related logic.

:param obs_url: URL to the OBS instance.
    :param project: Project to release. Must include the ``:GA`` suffix but not more.
    :param target: Decides what the release target is.
    :param osc_config: Path to the ``.oscrc``. It may be ``None`` if osc should handle the lookup.
    """
    releaser = OscReleaseHelper(osc_server=obs_url, override_config=osc_config)
    if target == ReleaseTargets.TEST:
        releaser.release_repo_to_test(project)
    elif target == ReleaseTargets.PUBLISH:
        releaser.release_repo_to_publish(project)

def main_cli(args):
    """
    Main routine that executes the script

:param args: Argparse Namespace that has all the arguments
    """
    main(args.osc_instance, args.project, args.release_target, args.osc_config)
0707010000002B000081A4000000000000000000000001638F17E500000906000000000000000000000000000000000000004600000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/search_binary.py"""
Retrieve the Channel, Project and Source Package for a list of given binaries.
"""

from typing import List

import requests

QUERY = """
query {{
  binaries(name_Iexact:"{}") {{
    edges {{
      node {{
        channelsources {{
          edges {{
            node {{
              channel {{
                name
              }}
              package {{
                name
              }}
              project {{
                name
              }}
            }}
          }}
        }}
      }}
    }}
  }}
}}
"""
SMELT_API = "https://smelt.suse.de/graphql/"

def build_parser(parent_parser):
    """
    Builds the parser for this script. This is executed by the main CLI dynamically.

:param parent_parser: The subparsers object from argparse.
    """
    subparser = parent_parser.add_parser("search_binary", help="search_binary help")
    subparser.add_argument(
        "binaries", metavar="binary", help="The binary names", nargs="+"
    )
    subparser.set_defaults(func=main_cli)

def get_binary_info(binary: str, timeout=180):
    """
    Retrieve all channel, project and source package names for a given binary.

:param binary: The name of the binaries that should be searched for.
    :param timeout: Timout when the connection should be aborted.
    :return: A Tuple with the name of the channel, project and source package is yielded.
    """
    query = {"query": QUERY.format(binary)}
    results = requests.post(SMELT_API, query, timeout=timeout).json()

for bin_result in results["data"]["binaries"]["edges"]:
        for result in bin_result["node"]["channelsources"]["edges"]:
            yield (
                result["node"]["channel"]["name"],
                result["node"]["project"]["name"],
                result["node"]["package"]["name"],
            )

def main(binaries: List[str]):
    """
    Main routine executes the non-CLI related logic.

:param binaries: The list of binaries that should be checked.
    """
    for binary in binaries:
        print(f"{binary}:")
        for chan, proj, pack in get_binary_info(binary):
            print(f" {chan}: {proj}/{pack}")

def main_cli(args):
    """
    Main routine that executes the script

:param args: Argparse Namespace that has all the arguments
    """
    main(args.binaries)
0707010000002C000081A4000000000000000000000001638F17E5000048AB000000000000000000000000000000000000004200000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/sle_build.py"""
This module is responsible to collect the current build numbers of the various images that are built.
"""
import concurrent.futures
import re
from typing import Dict, List, Optional
from urllib.error import HTTPError

from lxml import etree
from osc import conf, core  # type: ignore

class Build:
    """
    Helper class that holds data about a single build.
    """

# Disabled because dataclasses are not a thing in Python 3.6
    # pylint: disable=R0903

def __init__(self, name="", mtime=0):
        self.name = name
        self.mtime = mtime
        self.kind = ""
        self.number = ""

class SleBuildData:
    """
    Helper class that holds all the builds and image names in one object.
    """

# Disabled because dataclasses are not a thing in Python 3.6
    # pylint: disable=R0903

def __init__(self):
        self.codestream = ""
        self.builds_ga: Dict[str, Build] = {}
        self.builds_test: Dict[str, Build] = {}
        self.builds_publish: Dict[str, Build] = {}
        self.images_test = []
        self.images_publish = []
        self.images_wsl = []

def build_parser(parent_parser):
    """
    Builds the parser for this script. This is executed by the main CLI dynamically.

:param parent_parser: The subparsers object from argparse.
    """
    subparser = parent_parser.add_parser("sle_build", help="sle_build help")
    subparser.add_argument("version", metavar="V", help="project to get the builds for")
    subparser.set_defaults(func=main_cli)

def osc_prepare(osc_config: Optional[str] = None, osc_server: Optional[str] = None):
    """
    This has to be executed to the ini-style config is converted into their corresponding types.

def osc_get_builds(apiurl: str, project: str) -> List[Build]:
    """
    Get builds from the build-service.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :return: The list with the image names.
    """
    result = []
    query = {
        "package": "000product",
        "multibuild": "1",
        "repository": "images",
        "arch": "local",
        "view": "binarylist",
    }
    url = core.makeurl(apiurl, ["build", project, "_result"], query=query)
    file_object_builds = core.http_GET(url)
    tree = etree.parse(file_object_builds)
    binary_list = tree.xpath("//resultlist/result/binarylist/binary[@filename]")
    regex_iso_filename = re.compile(
        r".*(DVD|cd-cd|Packages|Full|Online)-x86_64.*Media1.iso$"
    )
    for binary in binary_list:
        filename_attribute = binary.get("filename")
        mtime_attribute = binary.get("mtime")
        if regex_iso_filename.match(filename_attribute):
            result.append(Build(filename_attribute, mtime_attribute))
    return result

def sle_15_media_build(apiurl: str, project: str) -> Dict[str, Build]:
    """
    Searches in the specified project for the current build flavors with their corresponding id.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :return: A dict where the keys are the build flavor and the values the build number.
    """
    result = {}
    regex_output = re.compile(
        r"(.*DVD|.*cd-cd|.*Packages|.*Full|.*Online)-x86_64-(Build.*)-Media1.iso"
    )
    for build in osc_get_builds(apiurl, project):
        build_number_match = regex_output.match(build.name)
        if build_number_match is None:
            raise ValueError("No regex match for build number!")
        build.kind = build_number_match.group(1)
        build.number = build_number_match.group(2)
        result[build.kind] = build
    return result

def osc_get_sle_non_release_packages(apiurl: str, project: str):
    """
    Retrieve all packages that are not related to a release.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :return: The list of packages.
    """
    package_list = core.meta_get_packagelist(apiurl, project)
    result = []
    for package in package_list:
        if package.startswith("SLE") and "release" not in package:
            result.append(package)
    return result

def osc_get_build_flavors(
    apiurl: str, project: str, package: str, filename: str
) -> list:
    """
    Reads the sources of a package to retrieve the allowed build flavors of an image.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :param package: The package where the multibuild file is located is.
    :param filename: The name of the multibuild file.
    :return: The list of flavors.
    """
    url = core.makeurl(apiurl, ["source", project, package, filename])
    try:
        file_object_osc_cat = core.http_GET(url)
    except HTTPError as error:
        if error.code == 404:
            # Package has no multibuild file
            return []
        raise
    root = etree.parse(file_object_osc_cat)
    elements = root.xpath("//multibuild/flavor")
    result = []
    for element in elements:
        result.append(element.text)
    return result

def osc_get_non_product_packages(apiurl: str, project: str) -> List[str]:
    """
    Get a list of packages that are unrelated to the product building progress.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :return: The list of packages.
    """
    package_list = core.meta_get_packagelist(apiurl, project)
    result = []
    package_list.remove("000product")
    for package in package_list:
        if "_product" in package or "kiwi" in package:
            continue
        result.append(package)
    return result

def get_kiwi_template(apiurl: str, project: str) -> str:
    """
    Retrieve the name of the kiwi template package

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :return: The full name of the kiwi-template package.
    """
    project_packages = core.meta_get_packagelist(apiurl, project)
    kiwi_template = ""
    for package in project_packages:
        if package.startswith("kiwi-templates"):
            kiwi_template = package
            break
    return kiwi_template

def get_sle_image_jeos_single(
    apiurl: str, project: str, repo, kiwi_template: str, i
) -> List[str]:
    """
    Search for JeOS images in a given project, repo and with the specified kiwi template.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :param repo: The repository to search for jeos images.
    :param kiwi_template: The full name of the kiwi package.
    :param i: The flavor of the package that is being searched for.
    :return: The images that have been found.
    """
    result = []
    binaries = core.get_binarylist(
        apiurl, project, repo.name, repo.arch, f"{kiwi_template}:{i}"
    )
    for binary in binaries:
        if binary.endswith(".packages"):
            result.append(binary[:-9])
    return result

def get_sle_images_jeos(apiurl: str, project: str, kiwi_template: str) -> List[str]:
    """
    multibuild JeOS

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :param kiwi_template: The full name of the kiwi package.
    :return: The list of names that the images from JeOS/Minimal will have.
    """
    result = []
    # core.get_repos_of_project returns an iterator
    repos = list(core.get_repos_of_project(apiurl, project))
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        futures = []
        for i in osc_get_build_flavors(apiurl, project, kiwi_template, "_multibuild"):
            for repo in repos:
                futures.append(
                    executor.submit(
                        get_sle_image_jeos_single,
                        apiurl,
                        project,
                        repo,
                        kiwi_template,
                        i,
                    )
                )
        for future in concurrent.futures.as_completed(futures):
            result.extend(future.result())
    return result

def get_sle_images_multibuild_single(
    apiurl: str, project: str, repo, package: str, flavor: str
):
    """
    Retrieve a list of images.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :param repo: The repository to get the images from.
    :param package: The package where the images are in.
    :param flavor: The flavor of the package that should be checked.
    :return: The list of images.
    """
    result = []
    binaries = core.get_binarylist(
        apiurl, project, repo.name, repo.arch, f"{package}:{flavor}"
    )
    for binary in binaries:
        if binary.endswith(".packages"):
            result.append(binary[:-9])
    return result

def get_sle_images_multibuild(apiurl: str, project: str):
    """
    Multibuild images such as cloud etc., typical name is "SLE12-SP5-EC2". This is for 15.2+ and 12.5+.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    """
    result = []
    # core.get_repos_of_project returns an iterator
    repos = list(core.get_repos_of_project(apiurl, project))
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        futures = []
        for package in osc_get_sle_non_release_packages(apiurl, project):
            for flavor in osc_get_build_flavors(
                apiurl, project, package, "_multibuild"
            ):
                for repo in repos:
                    futures.append(
                        executor.submit(
                            get_sle_images_multibuild_single,
                            apiurl,
                            project,
                            repo,
                            package,
                            flavor,
                        )
                    )
        for future in concurrent.futures.as_completed(futures):
            result.extend(future.result())
    return result

def get_sle_images_old_style_single(apiurl: str, project, repo, i):
    """
    Retrieve the old style image names.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :param repo: The repository to search for images.
    :param i: The package to search for old-style images.
    :return: The names of the images as a list.
    """
    result = []
    binaries = core.get_binarylist(apiurl, project, repo.name, repo.arch, i)
    for binary in binaries:
        if binary.endswith(".packages"):
            result.append(binary[:-9])
    return result

def get_sle_images_old_style(apiurl: str, project: str):
    """
    old style

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    """
    result = []
    # core.get_repos_of_project returns an iterator
    repos = []
    for repo in list(core.get_repos_of_project(apiurl, project)):
        if repo.name == "images":
            repos.append(repo)
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        futures = []
        for i in osc_get_non_product_packages(apiurl, project):
            for repo in repos:
                futures.append(
                    executor.submit(
                        get_sle_images_old_style_single, apiurl, project, repo, i
                    )
                )
        for future in concurrent.futures.as_completed(futures):
            result.extend(future.result())
    return result

def sle_images(apiurl: str, project: str) -> List[str]:
    """
    Collects all SLE 15 style images that can be found and sorts them.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look at.
    :return: The list of images that can be found.
    """
    temp_storage = []
    kiwi_template = get_kiwi_template(apiurl, project)
    if kiwi_template != "":
        jeos_images = get_sle_images_jeos(apiurl, project, kiwi_template)
        temp_storage.extend(jeos_images)

multibuild_images = get_sle_images_multibuild(apiurl, project)
    temp_storage.extend(multibuild_images)
    old_style_images = get_sle_images_old_style(apiurl, project)
    temp_storage.extend(old_style_images)

temp_storage.sort()
    return temp_storage

def osc_get_dvd_images(apiurl: str, version: str) -> List[str]:
    """
    Get all SLE 12 style DVD images.

:param apiurl: URL where the API from the build-service can be reached.
    :param version: The version of SLE to look for.
    :return: The list of images that can be found.
    """
    packages = core.meta_get_packagelist(apiurl, f"SUSE:SLE-{version}:GA")
    result = []
    product_regex = re.compile(r"_product.*(DVD-x86|cd-cd.*x86_64)")
    for package in packages:
        if product_regex.match(package):
            result.append(package)
    return result

def get_wsl_binaries(apiurl: str, project: str) -> List[str]:
    """
    This method avoids displaying images-test/$arch.

:param apiurl: URL where the API from the build-service can be reached.
    :param project: The project to look for WSL images in.
    :return: A list of names for build WSL images.
    """
    result = []
    try:
        binary_list = core.get_binarylist(
            apiurl,
            project,
            "standard",
            "x86_64",
            "wsl-appx",
        )
    except HTTPError as http_error:
        if http_error.code != 404:
            # All non 404 should be raised loudly
            raise
        # Something do not exist, thus no binary available
        binary_list = []

for binary in binary_list:
        if binary.endswith(".appx"):
            result.append(binary)
    return result

def osc_get_sle_12_images(apiurl: str, version: str) -> Dict[str, Build]:
    """
    Retrieves the list of SLE 12 images.

:param apiurl: URL where the API from the build-service can be reached.
    :param version: The version of SLE to check for.
    :return: A dict where the keys are build flavors and the values are build ids.
    """
    result = {}
    for image in osc_get_dvd_images(apiurl, version):
        my_media = core.get_binarylist(
            "https://api.suse.de/",
            f"SUSE:SLE-{version}:GA",
            "images",
            "local",
            package=image,
        )
        builds = []
        for media in my_media:
            if (
                media.endswith("Media1.iso") or media.endswith("Media.iso")
            ) and "x86_64" in media:
                builds.append(media)
        regex_build = re.compile(r"(.*)-DVD.*x86_64-(Build[0-9]+)-Media(1)?\.iso")
        if len(builds) == 1:
            my_match = regex_build.match(builds[0])
            if my_match is None:
                raise ValueError("No match for the regex of the build number!")
            build = Build(name=builds[0])
            build.kind = my_match.group(1)
            build.number = my_match.group(2)
            result[build.kind] = build
    return result

def main(apiurl: str, version: str, osc_config: Optional[str] = None) -> SleBuildData:
    """
    Main function to get the builds for the specified version.

:param apiurl: URL where the API from the build-service can be reached.
 :param version: The version of the product to check. Should be in format "<codestream>-SP<number>"
 :param osc_config: The config location for osc to use. If None then the default is retrieved by osc.
 :return: Object with the summarized data.
 """
 # Preparations
 result = SleBuildData()
 result.codestream = version.split("-", 1)[0]

# Prepare osc
    osc_prepare(osc_config=osc_config, osc_server=apiurl)

# Special cases
    if result.codestream == "15":
        result.builds_ga = sle_15_media_build(apiurl, f"SUSE:SLE-{version}:GA")
        result.builds_test = sle_15_media_build(apiurl, f"SUSE:SLE-{version}:GA:TEST")
        result.builds_publish = sle_15_media_build(
            apiurl, f"SUSE:SLE-{version}:GA:PUBLISH"
        )
    else:
        result.builds_ga = osc_get_sle_12_images(apiurl, version)

result.images_test = sle_images(apiurl, f"SUSE:SLE-{version}:GA:TEST")
    result.images_publish = sle_images(apiurl, f"SUSE:SLE-{version}:GA:PUBLISH")
    result.images_wsl = get_wsl_binaries(
        apiurl, f"SUSE:SLE-{version}:Update:WSL:Update:CR"
    )

return result

def main_cli(args):
    """
    Main routine that executes the script

:param args: Argparse Namespace that has all the arguments
    """
    data = main(args.osc_instance, args.version, osc_config=args.osc_config)
    if data.codestream == "15":
        print(f"builds from SUSE:SLE-{args.version}:GA:")
        for build, version in data.builds_ga.items():
            print(f"{build}:\t\t{version.number}")
        print("")

print(f"builds from SUSE:SLE-{args.version}:GA:TEST:")
        for build, version in data.builds_test.items():
            print(f"{build}:\t\t{version.number}")
        print("")

print(f"builds from SUSE:SLE-{args.version}:GA:PUBLISH")
        for build, version in data.builds_publish.items():
            print(f"{build}:\t\t{version.number}")
    else:
        print(f"builds from SUSE:SLE-{args.version}:GA:")
        for build, version in data.builds_ga.items():
            print(f"{build}:\t\t{version.number}")

# Normal process
    print("")
    print(f"images from SUSE:SLE-{args.version}:GA:TEST:")
    for image in data.images_test:
        print(image)

print("")
    print(f"images from SUSE:SLE-{args.version}:GA:PUBLISH:")
    for image in data.images_publish:
        print(image)

# avoid displaying images-test/$arch
    print("")
    print(f"WSL image (from SUSE:SLE-{args.version}:Update:WSL:Update:CR):")
    if len(data.images_wsl) > 0:
        for binary in data.images_wsl:
            print(binary)
    else:
        print("No binary available or package not found!")
0707010000002D000081A4000000000000000000000001638F17E5000045A3000000000000000000000000000000000000005100000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/update_build_status_page.py"""
Updates the build status page on Confluence for the service pack that is given with information from IBS.
"""

import getpass
import json
import os
import re
import subprocess
import sys
from datetime import date, datetime, timedelta
from typing import Any, Dict

import requests

JIRA_PASSWORD_FILE = os.path.expanduser("~/.jira_susedotcom_password")
NEXT_BUILD_DAYS = 7
PROJECT_TO_PAGE_MAP = {
    "test": {
        "page_id": 243269754,
        "url": "https://confluence.suse.com/display/SUSELinuxEnterpriseServer12SP5/Test",
    },
    "SUSE:SLE-12-SP5:GA": {
        "page_id": 227442811,
        "url": "https://confluence.suse.com/display/SUSELinuxEnterpriseServer12SP5/Build+status+SLE+12+SP5",
    },
    "SUSE:SLE-15-SP1:GA": {
        "page_id": 203129002,
        "url": "https://confluence.suse.com/display/SUSELinuxEnterpriseServer15SP1/Build+status",
    },
    "SUSE:SLE-15-SP2:GA": {
        "page_id": 255262891,
        "url": "https://confluence.suse.com/display/SUSELinuxEnterpriseServer15SP2/Build+Status",
    },
    "SUSE:SLE-15-SP3:GA": {
        "page_id": 415957115,
        "url": "https://confluence.suse.com/display/SUSELinuxEnterpriseServer15SP3/Build+Status",
    },
    "SUSE:SLE-15-SP4:GA": {
        "page_id": 798884391,
        "url": "https://confluence.suse.com/display/SUSELinuxEnterpriseServer15SP4/Build+Status",
    },
    "SUSE:SLE-15-SP5:GA": {
        "page_id": 1058603270,
        "url": "https://confluence.suse.com/display/SUSELinuxEnterpriseServer15SP5/Build+Status",
    },
}
NEXT_BUILD_DATE = None

page_cache: Dict[
    str, Any
] = {}  # to limit amount of rest calls {page_id: expanded_body.json}

def build_parser(parent_parser):
    """
    Builds the parser for this script. This is executed by the main CLI dynamically.

:param parent_parser: The subparsers object from argparse.
    """
    global NEXT_BUILD_DATE  # pylint: disable=W0603
    NEXT_BUILD_DATE = datetime.now() + timedelta(days=NEXT_BUILD_DAYS)

subparser = parent_parser.add_parser(
        "update_build_status_page", help="update_build_status_page help"
    )
    subparser.add_argument(
        "project",
        metavar="PROJECT",
        help="SUSE:PROJECT:GA",
        nargs=1,
        choices=PROJECT_TO_PAGE_MAP.keys(),
    )
    product_group = subparser.add_argument_group("Confluence Server related options")
    product_group.add_argument(
        "--next-build-date",
        help=f"YYYY-mm-dd Adjusts a date of next build. Default is in {date.strftime(NEXT_BUILD_DATE, '%Y-%m-%d')}",
        default=date.strftime(NEXT_BUILD_DATE, "%Y-%m-%d"),
    )
    product_group.add_argument(
        "--build-id",
        help="Build id is autodetected from output of sle_common/sle-build. But you can override it.",
    )
    product_group.add_argument(
        "--build-label",
        help="Will append label behind build id. E.g. Alpha-1.0-candidate",
    )
    server_group = subparser.add_argument_group("Confluence Server related options")
    server_group.add_argument(
        "--server",
        help="JIRA Server (devel by default), could be also url",
        default="https://confluence.suse.com/rest/api",
    )

server_group.add_argument(
        "--user", help=f"JIRA user [{os.getenv('USER')}]", default=os.getenv("USER")
    )
    server_group.add_argument("--auth", help="JIRA authentication", default="basic")
    server_group.add_argument(
        "--password",
        help=f"JIRA/Confluence password. Can be also stored in {JIRA_PASSWORD_FILE}",
    )
    subparser.set_defaults(func=main_cli)

def get_project(project: str):
    """
    Retrieves the desired project.

:param project: The project to work with.
    :return: The project or SLES 15 SP1 for testing.
    """
    if project == "test":
        return "SUSE:SLE-15-SP1:GA"
    return project

def free_page_cache(url: str):
    """
    Checks if a page is cached and removes it if it is.

:param url: The URL to check.
    """
    for addr in list(page_cache.keys()):
        if addr == "url" or addr.startswith(f"{url}?"):
            del page_cache[addr]

def confluence_generate_build_summary(
    server: str,
    user: str,
    password: str,
    project: str,
    build_id: int,
    build_label: str,
    changelog: str,
):
    """
    Merge manually pre-filled section for next build with changelog from the build

:param server: Confluence server URL
    :param user: The user for Confluence to log in with.
    :param password: The password for Confluence to log in with.
    :param project: The project in the IBS to work with.
    :param build_id: The override ID of the build that is being worked with.
    :param build_label: The override label of the build that is being worked with.
    :param changelog: The cached output of the ``sle_build`` script.
    :return: The generated build summary.
    """
    # pylint: disable=R0913
    build_str = str(build_id)
    if build_label:
        build_str = f"{build_id} - {build_label}"

pre_filled = confluence_get_next_build_section(
 server, user, password, page_id_by_project(project)
 )
 summary = pre_filled.replace(
 '<ac:parameter ac:name="title">Next build</ac:parameter>',
 f'<ac:parameter ac:name="title">Build {build_str} ({datetime.now().strftime("%Y%m%d")})</ac:parameter>',
 )
 # replace only the last or </ul> with or </ul> followed by ourlist
 summary = re.sub(
 r"(</[a-z]*>)\s*</ac:rich-text-body>",
 rf"\1 {to_html_list(changelog)}</ac:rich-text-body>",
 summary,
 )
 match = re.search(r'<time datetime="(?P<date>\d+-\d+-\d+)" />', summary)
 if match:
 summary = re.sub(
 r'<time datetime="\d+-\d+-\d+" />',
 f'<time datetime="{datetime.now().strftime("%Y-%m-%d")}" />',
 summary,
 )
 return summary

def confluence_get_prev_builds(server: str, user: str, password: str, project: str):
    """
    Retrieve the old page content of the specified project.

:param server: Confluence server URL
    :param user: The user for Confluence to log in with.
    :param password: The password for Confluence to log in with.
    :param project: The IBS project to work with.
    :return: The page content of the Confluence page for the specified IBS project.
    """
    content = confluence_get_page_content(
        server, user, password, page_id_by_project(project), expand=True
    )
    # print (content)
    content = content["body"]["storage"]["value"]
    next_build_section = confluence_get_next_build_section(
        server, user, password, page_id_by_project(project)
    )
    next_bs_start = content.find(next_build_section)
    return content[next_bs_start + len(next_build_section) :]

def to_html_list(data: str):
    """
    Converts a newline seperated str into a HTML tag seperated str.

:param data: The str to convert.
 :return: The str with newlines replaced by the HTML `` `` tag.
 """
 result = ""
 for line in data.split("\n"):
 if line.strip():
 result += f"{line} "
 return result

def get_last_build_number(project, changelog=None):
    """
    Retrieves the last build ID from the ``sle_build`` script.

:param project: The project name in IBS.
    :param changelog: The changelog from the build.
    :return: The build number.
    """
    # I'm getting build id as the highest number from the changelog
    # sle12 and sle15 both have different syntax
    versions = set()
    if not changelog:
        changelog = get_last_build_changelog(
            project
        )  # reuse if possible, it takes a lot of time

project = get_project(project)

if project.startswith("SUSE:SLE-12"):
        # SLE-12-SP5-HPC:		Build0151
        for line in changelog.split("\n"):
            version = re.search("([0-9]+)$", line)
            if version:
                versions.add(int(version.groups()[0]))
    elif project.startswith("SUSE:SLE-15"):
        # SLE-15-SP1-Installer:		Build224.10
        for line in changelog.split("\n"):
            version = re.search(r"([0-9]+\.[0-9]+)$", line)
            if version:
                versions.add(float(version.groups()[0]))
    # print versions
    return str(sorted(versions)[-1])  # sorted

def get_last_build_changelog(project: str):
    """
    Retrieves the output of the ``sle_build`` script.

:param project: The project name in IBS.
    :return: The output of the ``sle_build`` script.
    """
    # Build id is ignored
    project = get_project(project)

prj_match = re.search(r"SLE-(\d+-\w+):\w+", project)
    if prj_match is None:
        raise ValueError("Could not get project name from given project!")
    prj = prj_match.groups(0)[0]
    cmd = f"{os.path.join(os.path.dirname(os.path.realpath(__file__)), 'sle-build')} {prj}"
    out = subprocess.check_output(cmd, shell=True)
    # Python3 returns bytes-like obj
    if not isinstance(out, str):
        return out.decode("utf-8")
    return out

def page_id_by_project(project: str):
    """
    Retrieve the page ID in Confluence by the IBS project name.

:param project: The project name in IBS.
    :return: The page ID in Confluence.
    """
    return PROJECT_TO_PAGE_MAP[project]["page_id"]

def page_url_by_project(project: str):
    """
    Retrieve the page URL in Confluence by the IBS project name.

:param project: The project name in IBS.
    :return: The URL to Confluence.
    """
    return PROJECT_TO_PAGE_MAP[project]["url"]

def confluence_get_next_build_section(
    server: str, user: str, password: str, page_id: int
):
    """
    Retrieve a section of a specified Confluence page.

:param server: Confluence server URL
 :param user: The user for Confluence to log in with.
 :param password: The password for Confluence to log in with.
 :param page_id: The ID of the Confluence page.
 :return: The content of the desired page.
 """
 content = confluence_get_page_content(server, user, password, page_id, expand=True)
 # print content
 content = content["body"]["storage"]["value"]
 next_build_section = content[
 content.find("<ac:structured-macro") : content.find("</ac:structured-macro>")
 + len("</ac:structured-macro>")
 ]
 return next_build_section

def generate_new_build_section(next_build_date: date):
    """
    Generates a section for the next build that will be released.

:param next_build_date: The date that will be used for the next build.
 :return: The Confluence formatted section for the next build.
 """
 next_build = f"""
 <ac:structured-macro ac:name="expand" ac:schema-version="1" ac:macro-id="6541c1a0-8ae5-4076-975c-7eb3c22fc21e">
 <ac:parameter ac:name="title">Next build</ac:parameter>
 <ac:rich-text-body>
 <time datetime="{date.strftime(next_build_date, "%Y-%m-%d")}" />
 &nbsp;&nbsp;-----------------------------------------------------------------
 </ac:rich-text-body>
 </ac:structured-macro>"""
 return next_build.replace("\n", "")

def confluence_get_page_content(
    server: str, user: str, password: str, page_id: int, expand=False
):
    """
    Retrieves the page content of a Confluence page.

:param server: Confluence server URL
    :param user: The user for Confluence to log in with.
    :param password: The password for Confluence to log in with.
    :param page_id: The ID of the Confluence page.
    :param expand: Whether the page should be expanded or not.
    :return: The page content.
    """
    url = f"{server}/content/{page_id:d}"
    if expand:
        url += "?expand=body.storage"

if url not in page_cache:
        auth = (user, password)
        confluence_request = requests.get(url, auth=auth, timeout=180)
        # print (url)
        if confluence_request.status_code == 401:
            raise ValueError("Authentication fail")
        page_cache[url] = confluence_request.json()
    return page_cache[url]

def confluence_get_page_heading(server: str, user: str, password: str, project: str):
    """
    Retrieves the heading of a Confluence page.

:param server: Confluence server URL
    :param user: The user for Confluence to log in with.
    :param password: The password for Confluence to log in with.
    :param project: The project in the IBS to work with.
    :return: The heading of the confluence page for the IBS project.
    """
    content = confluence_get_page_content(
        server, user, password, page_id_by_project(project), expand=True
    )
    # print(content)
    content = content["body"]["storage"]["value"]
    next_build_section = confluence_get_next_build_section(
        server, user, password, page_id_by_project(project)
    )
    next_bs_start = content.find(next_build_section)
    return content[:next_bs_start]

def confluence_set_page_content(
    server: str, user: str, password: str, page_id: int, json_content
):
    """
    Update a Confluence page with the given content.

:param server: Confluence server URL
    :param user: The user for Confluence to log in with.
    :param password: The password for Confluence to log in with.
    :param page_id: The page ID to update.
    :param json_content: The JSON content that the Confluence API should expect.
    """
    current_data = confluence_get_page_content(server, user, password, page_id)
    new_data = {
        "id": page_id,
        "type": current_data["type"],
        "space": {"key": current_data["space"]["key"]},
        "title": current_data["title"],
        "version": {"number": int(current_data["version"]["number"]) + 1},
    }
    new_data.setdefault("body", {}).setdefault(
        "storage", {"representation": "storage"}
    )["value"] = json_content
    # print(json.dumps(new_data, indent=4, sort_keys=True))

url = f"{server}/content/{page_id:d}"
    free_page_cache(url)

confluence_request = requests.put(
        url,
        data=json.dumps(new_data),
        auth=(user, password),
        headers={"Content-Type": "application/json", "Accept": "application/json"},
        timeout=180,
    )

try:
        confluence_request.raise_for_status()
    except requests.HTTPError as http_error:
        print(http_error.response.text)
        raise http_error

def confluence_update_build_summary(
    server: str,
    user: str,
    password: str,
    project: str,
    build_id: int,
    changelog,
    next_build_date: date,
    build_label,
):
    """
    Updates the build summary of a Confluence page for a certain IBS project.

:param server: Confluence server URL
    :param user: The user for Confluence to log in with.
    :param password: The password for Confluence to log in with.
    :param project: The project in the IBS to work with.
    :param build_id: The override ID of the build that is being worked with.
    :param changelog: The cached output of the ``sle_build`` script.
    :param next_build_date: Date of the next build.
    :param build_label: The override label of the build that is being worked with.
    """
    # pylint: disable=R0913
    new_page_body = confluence_get_page_heading(server, user, password, project)
    new_page_body += generate_new_build_section(next_build_date)
    new_page_body += confluence_generate_build_summary(
        server, user, password, project, build_id, build_label, changelog
    )

new_page_body += confluence_get_prev_builds(server, user, password, project)
    confluence_set_page_content(
        server, user, password, page_id_by_project(project), new_page_body
    )

def main(
    server: str,
    user: str,
    password: str,
    build_id,
    build_label,
    next_build_date: str,
    project: str,
):
    """
    Main routine executes the non-CLI related logic.

:param server: Confluence server URL
    :param user: The user for Confluence to log in with.
    :param password: The password for Confluence to log in with.
    :param build_id: The override ID of the build that is being worked with.
    :param build_label: The override label of the build that is being worked with.
    :param next_build_date: The date of the next build.
    :param project: The project in the IBS to work with.
    """
    # pylint: disable=R0913
    if not password:

if os.path.exists(JIRA_PASSWORD_FILE):
            try:
                with open(JIRA_PASSWORD_FILE, encoding="UTF-8") as fp_password_file:
                    user, password = fp_password_file.read().strip().split("\n")
            except ValueError:
                print(
                    f"Error: {JIRA_PASSWORD_FILE} is supposed to contain exactly two lines user and password."
                )
                sys.exit(1)

else:
            print(
                f"You can save confluence/jira user and password into {JIRA_PASSWORD_FILE} (two separate lines). To"
                "avoid re-entering"
            )
            password = getpass.getpass(
                f"Please enter {server} password for user {user}: "
            )

changelog = get_last_build_changelog(project)
    if not build_id:
        build_id = get_last_build_number(project, changelog=changelog)

confluence_update_build_summary(
        server,
        user,
        password,
        project,
        build_id,
        changelog,
        datetime.strptime(next_build_date, "%Y-%m-%d"),
        build_label,
    )

print(f"Updated {page_url_by_project(project)}")

def main_cli(args):
    """
    Main routine that executes the script

:param args: Argparse Namespace that has all the arguments
    """
    main(
        args.server,
        args.user,
        args.password,
        args.build_id,
        args.build_label,
        args.next_build_date,
        args.project[0],
    )
0707010000002E000041ED000000000000000000000002638F17E500000000000000000000000000000000000000000000003B00000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/utils0707010000002F000081A4000000000000000000000001638F17E500000072000000000000000000000000000000000000004700000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/utils/__init__.py"""
This utils module should contain code that is shared between more than one release management CLI module.
"""
07070100000030000081A4000000000000000000000001638F17E500000055000000000000000000000000000000000000004900000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/utils/confluence.py"""
This module should contain helper functionality that assists for Confluence.
"""
07070100000031000081A4000000000000000000000001638F17E500001745000000000000000000000000000000000000004300000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/utils/jira.py"""
This module should contain helper functionality that assists for Jira.
"""
import logging
from collections import namedtuple
from typing import Dict, List, Union

import jira

SSLOptions = namedtuple("SSLOptions", "check_cert truststore")

class JiraUtils:
    """
    This class contains the shared functions that will enable scripts to interact with JIRA.
    """

def __init__(self, jira_url: str, pat_token: str, ssl_options: SSLOptions):
        """
        Default constructor that initializes the object.

Authentication is only possible doing PAT. For more information follow up on the Atlassian Documentation:

https://confluence.atlassian.com/enterprise/using-personal-access-tokens-1026032365.html

:param jira_url: URL to access the JIRA instance.
        :param pat_token: The token to access the JIRA instance. Will define if a script can access the required
                          resources.
        :param ssl_options: The NamedTuple that contains the options to configure the SSL setup.
        """
        self.logger = logging.getLogger()
        self.jira_url = jira_url
        options = self.__prepare_ssl_options(ssl_options)
        self.jira_obj = jira.JIRA(
            self.jira_url,
            options=options,
            token_auth=pat_token,
        )

@staticmethod
    def __prepare_ssl_options(ssl_options: SSLOptions) -> dict:
        """
        Prepares the SSL options dict for the JIRA Client.

:param ssl_options: The NamedTuple that contains the options to configure the SSL setup.
        :return: The dictionary that will be passed to the JIRA library and in the end to requests.
        """
        result: Dict[str, Union[str, bool]] = {}
        if ssl_options.check_cert:
            result["verify"] = ssl_options.truststore
        else:
            result["verify"] = False
        return result

def jira_get_field_values(self, field_id: str, issue: str) -> Dict[str, str]:
        """
        Retrieves a list of all available field values in a select or multi-select.

:param field_id: The ID of the field that the values should be retrieved for.
        :param issue: The issue that decides the field values that are available to search for.
        :return: The dict of possible field values or an empty dict. Keys represent the names and values are the IDs.
        """
        result = {}
        issue_obj = self.jira_obj.issue(issue)
        meta = self.jira_obj.editmeta(issue_obj.key)
        for option in meta["fields"][field_id]["allowedValues"]:
            result[option.get("value")] = option.get("id")
        return result

def jira_get_field_name(self, name: str) -> str:
        """
        Retrieve the field ID by the name of the field that an end user sees.

:param name: The name of the field.
        :return: The field ID or an emtpy string.
        """
        result = ""
        jira_fields = self.jira_obj.fields()
        for field in jira_fields:
            if field.get("name") == name:
                field_id = field.get("id")
                if isinstance(field_id, str):
                    result = field_id
                    break
                # Should never happen since the ID is always
                # a str but mypy requires this logic.
                continue
        return result

def jira_get_version_obj(self, issue: str, name: str):
        """
        Get the version object that represents a version in JIRA:

:param issue: The issue that decides the versions that are available to search for.
        :param name: The name of the version that should be retrieved
        :return: The full version object as returned by the JIRA library.
        """
        issue_obj = self.jira_obj.issue(issue)
        project = issue_obj.get_field("project")
        for version in self.jira_obj.project_versions(project):
            if version.name == name:
                return version
        return None

def jira_get_transition_id(self, jsc: str, transition_name: str) -> str:
        """
        Retrieve the transition ID of a ticket by the transition name.

:param jsc: The Jira ticket number.
        :param transition_name: Name of the transition.
        :return: The target transition ID or an empty str.
        """
        transitions = self.jira_obj.transitions(jsc)
        target_transition_id = ""
        for transition in transitions:
            if transition.get("name") == transition_name:
                target_transition_id = transition.get("id")
        return target_transition_id

def jira_transition_tickets(self, jsc: str) -> None:
        """
        Transition an issue in the workflow if it is in the correct state. If not log a message.

:param jsc: The Jira ticket number.
        """
        target_transition_id = self.jira_get_transition_id(jsc, "Integrated")
        if target_transition_id == "":
            self.logger.error(
                'Issue "%s" could not be transitioned to the state "QE Open" because the transition could not be'
                " identified!",
                jsc,
            )
            return
        self.jira_obj.transition_issue(jsc, target_transition_id)

def jira_do_search(self, jql: str, max_results: int = 50) -> List[str]:
        """
        Perform a JIRA search.

JQL documentation: https://confluence.atlassian.com/jiracoreserver073/advanced-searching-861257209.html

:param jql: The JQL that should be used for searching.
        :param max_results: The number of results that should be
        :return: The list of issue keys that match the filter. The number of results is limited by ``max_results``.
        """
        result: List[str] = []
        for issue in self.jira_obj.search_issues(jql, maxResults=max_results):
            if isinstance(jira.Issue, str):
                result.append(issue.key)
        return result
07070100000032000081A4000000000000000000000001638F17E500002394000000000000000000000000000000000000004200000000sle-prjmgr-tools-1670322149.d38bfb5/sle_prjmgr_tools/utils/osc.py"""
This module should contain helper functionality that assists for the Open Build Service.
"""
import re
import sys
import time
from typing import List, Optional

from lxml import etree
from osc import conf, core  # type: ignore

class OscUtils:
    """
    This class contains the shared functions that will enable scripts to interact with an Open Build Service instance.
    """

def __init__(
        self,
        osc_server: str = "https://build.opensuse.org",
        override_config: Optional[str] = None,
    ):
        """
        Default constructor that initializes the object.

:param osc_server: Server URL that points to the OBS server API.
        :param override_config: Path to the configuration file for osc. The default delegates the task to the
                                osc library.
        """
        self.osc_server = osc_server
        self.osc_web_ui_url = ""
        self.override_config = override_config
        self.osc_prepare()

def osc_prepare(self) -> None:
        """
        This has to be executed to the ini-style config is converted into their corresponding types.
        """
        conf.get_config(
            override_conffile=self.override_config, override_apiurl=self.osc_server
        )

@staticmethod
 def convert_project_to_product(project: str) -> str:
 """
 Assumes the following schema: RootProject:SomeSubProject:MoreProjects:SLE-<digits>-SP<digits>:SomeProject

:param project: Project to convert
 :return: A str in the form "SLES<major>-SP<SP version>".
 """
 project_parts = project.split(":")
 product_version = project_parts[-2].split("-")
 result = f"SLES{product_version[1]}-{product_version[2]}"
 return result

def osc_get_web_ui_url(self) -> str:
        """
        Search the API for the Web UI URL.

:return: The URL of the WebUI for OBS.
        """
        if self.osc_web_ui_url != "":
            return self.osc_web_ui_url
        obs_config_xml = core.show_configuration(self.osc_server)
        root = etree.fromstring(obs_config_xml)
        node = root.find("obs_url")
        if node is None or not node.text:
            raise ValueError("obs_url configuration element expected")
        self.osc_web_ui_url = node.text
        return self.osc_web_ui_url

def osc_is_repo_published(self, project: str, repository: str) -> bool:
        """
        Checks if the repository in the specified project is already published. This does not reflect if the current
        build is published just that the build available via the API is published.

:param project: The project that should be checked.
        :param repository: The repository that should be checked.
        :return: True if the repository is published.
        """
        url = core.makeurl(
            self.osc_server,
            ["build", project, "_result"],
            query={"view": "summary", "repository": repository},
        )
        with core.http_GET(url) as result:
            my_str = result.read().decode()
        root = etree.fromstring(my_str)
        my_nodes = root.xpath(f'/resultlist/result[@project="{project}"]')
        return all(
            (
                node.get("code") == "published" and node.get("state") == "published"
                for node in my_nodes
            )
        )

def osc_get_containers(self, project: str) -> List[str]:
        """
        Searches in a given project for the packages that correspond to containers.

:param project: The project that should be searched in.
        :return: The list of str with package names that match the container regex.
        """
        package_list = core.meta_get_packagelist(self.osc_server, project)
        container_regex = re.compile(r"^(cdi|virt)-.*-container")
        result: List[str] = []
        for package_name in package_list:
            if container_regex.match(package_name):
                result.append(package_name)
        return result

def osc_get_products(self, project: str) -> List[str]:
        """
        Get all packages that belong to products being built in this project.

:param project: The project to check for.
        :return: The list of packages that match the criteria. Might be empty.
        """
        package_list = core.meta_get_packagelist(self.osc_server, project)
        products_regex = re.compile(rf"^{self.convert_project_to_product(project)}")
        result: List[str] = []
        for package_name in package_list:
            if products_regex.match(package_name) and "release" not in package_name:
                result.append(package_name)
        return result

def osc_get_jsc_from_sr(self, sr_number: int) -> List[str]:
        """
        Get all jsc's from a single Submit Request in the Open Build Service.

:param sr_number: The submit request number that should be checked.
        :return: The list of jsc's that were mentioned.
        """
        issues = core.get_request_issues(self.osc_server, str(sr_number))
        result = []
        for issue in issues:
            if issue.get("tracker") == "jsc":
                result.append(issue.get("name"))
        return result

def osc_do_release(
        self,
        project: str,
        package: str = "",
        repo: str = "",
        target_project: str = "",
        target_repository: str = "",
        no_delay: bool = False,
    ) -> None:
        """
        Perform a release for a given project.

:param project: The project to release.
        :param package: Release only a specific package.
        :param repo: The repository that should be published.
        :param target_project: The target project where to release to.
        :param target_repository: The target repository where to release to.
        :param no_delay: If the action should be regularly scheduled or if it should be performed immediately
        """
        # pylint: disable=R0913
        baseurl = ["source", project]
        query = {"cmd": "release"}
        if package:
            baseurl.append(package)
        if repo:
            query["repository"] = repo
        if target_project:
            query["target_project"] = target_project
        if target_repository:
            query["target_repository"] = target_repository
        if no_delay:
            query["nodelay"] = "1"
        url = core.makeurl(self.osc_server, baseurl, query=query)
        fp_post_result = core.http_POST(url)
        while True:
            buf = fp_post_result.read(16384)
            if not buf:
                break
            sys.stdout.write(core.decode_it(buf))

class OscReleaseHelper(OscUtils):
    """
    Helper class to deduplicate between the different release scripts.
    """

def release_to_common(self, project: str) -> None:
 """
 This consolidates common steps that are required to release a project. Specifics should be implemented in
 ``release_repo_to_<target>``.

:param project: The project that will be released.
        """
        time.sleep(60)
        while not self.osc_is_repo_published(project, "containers"):
            print("containers: PENDING")
            time.sleep(60)
        if self.osc_is_repo_published(project, "containers"):
            print("containers: PUBLISHED")
        while not self.osc_is_repo_published(project, "images"):
            print("images: PENDING")
            time.sleep(60)
        if self.osc_is_repo_published(project, "images"):
            print("images: PUBLISHED")

def release_repo_to_test(self, project: str) -> None:
        """
        Releases a ``:GA`` to ``:GA:TEST``. This is a synchronous call that will block until it is done.

:param project: The project including the ``:GA`` suffix.
        """
        for container in self.osc_get_containers(project):
            self.osc_do_release(
                project,
                package=container,
                repo="containerfile",
                target_project=f"{project}:TEST",
                target_repository="containers",
            )
        self.osc_do_release(
            project,
            "sles15-image",
            repo="images",
            target_project=f"{project}:TEST",
            target_repository="containers",
        )
        products = self.osc_get_products(project)
        if products == "":
            print("[WARNING] There is no cloud image to be released")
        products.insert(0, "000product")
        products.insert(0, "kiwi-templates-Minimal")
        for product in products:
            self.osc_do_release(project, package=product)
        self.release_to_common(f"{project}:TEST")

def release_repo_to_publish(self, project: str) -> None:
        """
        Releases a ``:GA:TEST`` to ``:GA:PUBLISH``. This is a synchronous call that will block until it is done.

:param project: The project including the ``:GA`` suffix.
        """
        self.osc_do_release(f"{project}:TEST")
        self.release_to_common(f"{project}:GA:PUBLISH")
07070100000033000041ED000000000000000000000003638F17E500000000000000000000000000000000000000000000002A00000000sle-prjmgr-tools-1670322149.d38bfb5/tests07070100000034000041ED000000000000000000000002638F17E500000000000000000000000000000000000000000000002F00000000sle-prjmgr-tools-1670322149.d38bfb5/tests/data07070100000035000081A4000000000000000000000001638F17E500000005000000000000000000000000000000000000003A00000000sle-prjmgr-tools-1670322149.d38bfb5/tests/data/.gitignoreoscrc07070100000036000081A4000000000000000000000001638F17E50000009E000000000000000000000000000000000000003E00000000sle-prjmgr-tools-1670322149.d38bfb5/tests/data/oscrc.template[general]
apiurl = https://api.suse.de

[https://api.suse.de]
user=<username>
sshkey=id_rsa
credentials_mgr_class=osc.credentials.TransientCredentialsManager
07070100000037000081A4000000000000000000000001638F17E500000000000000000000000000000000000000000000004500000000sle-prjmgr-tools-1670322149.d38bfb5/tests/release_to_publish_test.py07070100000038000081A4000000000000000000000001638F17E500000000000000000000000000000000000000000000004200000000sle-prjmgr-tools-1670322149.d38bfb5/tests/release_to_test_test.py07070100000039000081A4000000000000000000000001638F17E500000EBF000000000000000000000000000000000000003C00000000sle-prjmgr-tools-1670322149.d38bfb5/tests/sle_build_test.pyimport pytest

from sle_prjmgr_tools import sle_build

@pytest.fixture(scope="function", autouse=True)
def setup_osc():
    sle_build.osc_prepare("tests/data/oscrc", "https://api.suse.de")

def test_osc_get_builds():
    # Arrange
    apiurl = "https://api.suse.de"
    project = "SUSE:SLE-15-SP5:GA:TEST"

# Act
    result = sle_build.osc_get_builds(apiurl, project)