chgksuite 0.27.2__tar.gz → 0.28.0__tar.gz

{chgksuite-0.27.2 → chgksuite-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chgksuite
-Version: 0.27.2
+Version: 0.28.0
 Summary: A package for chgk automation
 Project-URL: Homepage, https://gitlab.com/peczony/chgksuite
 Author-email: Alexander Pecheny <ap@pecheny.me>

{chgksuite-0.27.2 → chgksuite-0.28.0}/chgksuite/cli.py

@@ -12,6 +12,7 @@ from chgksuite.common import (
     load_settings,
 )
 from chgksuite.composer import gui_compose
+from chgksuite.composer.telegram import get_saved_telegram_targets
 from chgksuite.handouter.runner import gui_handouter
 from chgksuite.parser import gui_parse
 from chgksuite.trello import gui_trello
@@ -34,7 +35,14 @@ class ArgparseBuilder:
         if self.use_wrapper:
             return getattr(parser, func)(*args, **kwargs)
         else:
-            for k in ("caption", "advanced", "argtype", "hide", "filetypes"):
+            for k in (
+                "caption",
+                "advanced",
+                "argtype",
+                "hide",
+                "filetypes",
+                "combobox_values",
+            ):
                 try:
                     kwargs.pop(k)
                 except KeyError:
@@ -654,12 +662,15 @@ class ArgparseBuilder:
             help="a made-up string designating account to use.",
             caption="Аккаунт для постинга",
         )
+        saved_targets = get_saved_telegram_targets()
         self.add_argument(
             cmdcompose_telegram,
             "--tgchannel",
             required=True,
             help="a channel to post questions to.",
             caption="Название канала, в который постим",
+            argtype="combobox",
+            combobox_values=saved_targets,
         )
         self.add_argument(
             cmdcompose_telegram,
@@ -667,6 +678,8 @@ class ArgparseBuilder:
             required=True,
             help="a chat connected to the channel.",
             caption="Название чата, привязанного к каналу",
+            argtype="combobox",
+            combobox_values=saved_targets,
         )
         self.add_argument(
             cmdcompose_telegram,

{chgksuite-0.27.2 → chgksuite-0.28.0}/chgksuite/composer/telegram.py

@@ -17,6 +17,28 @@ from chgksuite.composer.composer_common import BaseExporter, parseimg
 from chgksuite.composer.telegram_bot import run_bot_in_thread
 
 
+def get_saved_telegram_targets():
+    """
+    Load all saved channel/chat usernames from resolve.db.
+    Returns a list of usernames that have been previously used.
+    """
+    chgksuite_dir = get_chgksuite_dir()
+    resolve_db_path = os.path.join(chgksuite_dir, "resolve.db")
+
+    if not os.path.exists(resolve_db_path):
+        return []
+
+    try:
+        conn = sqlite3.connect(resolve_db_path)
+        cursor = conn.cursor()
+        cursor.execute("SELECT username FROM resolve ORDER BY username")
+        results = cursor.fetchall()
+        conn.close()
+        return [row[0] for row in results]
+    except Exception:
+        return []
+
+
 def get_text(msg_data):
     if "message" in msg_data and "text" in msg_data["message"]:
         return msg_data["message"]["text"]
@@ -44,19 +66,14 @@ class TelegramExporter(BaseExporter):
         self.chat_id = None  # Discussion group ID linked to the channel
         self.auth_uuid = uuid.uuid4().hex[:8]
         self.chat_auth_uuid = uuid.uuid4().hex[:8]
+        self.session = requests.Session()
         self.init_telegram()
 
     def check_connectivity(self):
-        req_me = requests.get(f"https://api.telegram.org/bot{self.bot_token}/getMe")
-        if req_me.status_code != 200:
-            raise Exception(
-                f"getMe request wasn't successful: {req_me.status_code} {req_me.text}"
-            )
-        obj = req_me.json()
-        assert obj["ok"]
+        result = self.send_api_request("getMe")
         if self.args.debug:
-            print(f"connection successful! {obj}")
-        self.bot_id = obj["result"]["id"]
+            print(f"connection successful! {result}")
+        self.bot_id = result["id"]
 
     def init_temp_db(self):
         self.db_conn = sqlite3.connect(self.temp_db_path)
@@ -102,8 +119,6 @@ class TelegramExporter(BaseExporter):
             ).fetchall()
             if messages and json.loads(messages[0][0])["status"] == "ok":
                 break
-        # Request user authentication
-        self.authenticate_user()
 
     def authenticate_user(self):
         print("\n" + "=" * 50)
@@ -208,32 +223,46 @@ class TelegramExporter(BaseExporter):
     def send_api_request(self, method, data=None, files=None):
         """Send a request to the Telegram Bot API."""
         url = f"https://api.telegram.org/bot{self.bot_token}/{method}"
+        retry_delay = 10  # Start with 10 seconds
+        max_retry_delay = 120  # Cap at 2 minutes
 
-        try:
-            if files:
-                response = requests.post(url, data=data, files=files, timeout=60)
-            else:
-                response = requests.post(url, json=data, timeout=30)
+        while True:
+            try:
+                if files:
+                    response = self.session.post(
+                        url, data=data, files=files, timeout=60
+                    )
+                else:
+                    response = self.session.post(url, json=data, timeout=30)
 
-            response_data = response.json()
+                response_data = response.json()
 
-            if not response_data.get("ok"):
-                error_message = response_data.get("description", "Unknown error")
-                self.logger.error(f"Telegram API error: {error_message}")
+                if not response_data.get("ok"):
+                    error_message = response_data.get("description", "Unknown error")
+                    self.logger.error(f"Telegram API error: {error_message}")
 
-                # Handle rate limiting
-                if "retry_after" in response_data:
-                    retry_after = response_data["retry_after"]
-                    self.logger.info(f"Rate limited. Waiting for {retry_after} seconds")
-                    time.sleep(retry_after + 1)
-                    return self.send_api_request(method, data, files)
+                    # Handle rate limiting
+                    if "retry_after" in response_data:
+                        retry_after = response_data["retry_after"]
+                        self.logger.info(
+                            f"Rate limited. Waiting for {retry_after} seconds"
+                        )
+                        time.sleep(retry_after + 1)
+                        return self.send_api_request(method, data, files)
 
-                raise Exception(f"Telegram API error: {error_message}")
+                    raise Exception(f"Telegram API error: {error_message}")
 
-            return response_data["result"]
-        except requests.exceptions.RequestException as e:
-            self.logger.error(f"Request error: {e}")
-            raise
+                return response_data["result"]
+            except requests.exceptions.RequestException as e:
+                if "Connection reset by peer" in str(e):
+                    self.logger.warning(
+                        f"Connection reset by peer. Retrying in {retry_delay} seconds..."
+                    )
+                    time.sleep(retry_delay)
+                    retry_delay = min(retry_delay * 2, max_retry_delay)
+                    continue
+                self.logger.error(f"Request error: {e}")
+                raise
 
     def get_message_link(self, chat_id, message_id, username=None):
         """Generate a link to a Telegram message."""
@@ -851,66 +880,82 @@ class TelegramExporter(BaseExporter):
         channel_result = self.extract_id_from_link(self.args.tgchannel)
         chat_result = self.extract_id_from_link(self.args.tgchat)
 
-        # Handle channel resolution
+        # First, try to resolve both IDs without user interaction
+        channel_id = None
+        chat_id = None
+        needs_channel_interaction = False
+        needs_chat_interaction = False
+
         if isinstance(channel_result, int):
             channel_id = channel_result
         elif isinstance(channel_result, str):
             channel_id = self.resolve_username_to_id(channel_result)
             if not channel_id:
-                print("\n" + "=" * 50)
-                print("Please forward any message from the target channel to the bot.")
-                print("This will allow me to extract the channel ID automatically.")
-                print("=" * 50 + "\n")
-
-                # Wait for a forwarded message with channel information
-                channel_id = self.wait_for_forwarded_message(
-                    entity_type="channel", check_type=True
-                )
-                if channel_id:
-                    self.save_username(channel_result, channel_id)
-                else:
-                    raise Exception("Failed to get channel ID from forwarded message")
+                needs_channel_interaction = True
         else:
             raise Exception("Channel ID is undefined")
 
-        # Handle chat resolution
         if isinstance(chat_result, int):
             chat_id = chat_result
         elif isinstance(chat_result, str):
             chat_id = self.resolve_username_to_id(chat_result)
             if not chat_id:
-                print("\n" + "=" * 50)
-                print(
-                    f"Please write a message in the discussion group with text: {self.chat_auth_uuid}"
-                )
-                print("This will allow me to extract the group ID automatically.")
-                print(
-                    "The bot MUST be added do the group and made admin, else it won't work!"
-                )
-                print("=" * 50 + "\n")
+                needs_chat_interaction = True
+        else:
+            raise Exception("Chat ID is undefined")
 
-                # Wait for a forwarded message with chat information
+        # Only authenticate if we need user interaction
+        if needs_channel_interaction or needs_chat_interaction:
+            self.authenticate_user()
+
+        # Handle channel resolution with user interaction if needed
+        if needs_channel_interaction:
+            print("\n" + "=" * 50)
+            print("Please forward any message from the target channel to the bot.")
+            print("This will allow me to extract the channel ID automatically.")
+            print("=" * 50 + "\n")
+
+            # Wait for a forwarded message with channel information
+            channel_id = self.wait_for_forwarded_message(
+                entity_type="channel", check_type=True
+            )
+            if channel_id:
+                self.save_username(channel_result, channel_id)
+            else:
+                raise Exception("Failed to get channel ID from forwarded message")
+
+        # Handle chat resolution with user interaction if needed
+        if needs_chat_interaction:
+            print("\n" + "=" * 50)
+            print(
+                f"Please write a message in the discussion group with text: {self.chat_auth_uuid}"
+            )
+            print("This will allow me to extract the group ID automatically.")
+            print(
+                "The bot MUST be added do the group and made admin, else it won't work!"
+            )
+            print("=" * 50 + "\n")
+
+            # Wait for a forwarded message with chat information
+            chat_id = self.wait_for_forwarded_message(
+                entity_type="chat", check_type=False
+            )
+            if not chat_id:
+                self.logger.error("Failed to get chat ID from forwarded message")
+                return False
+            while chat_id == channel_id:
+                error_msg = (
+                    "Chat ID and channel ID are the same. The problem may be that "
+                    "you posted a message in the channel, not in the discussion group."
+                )
+                self.logger.error(error_msg)
                 chat_id = self.wait_for_forwarded_message(
-                    entity_type="chat", check_type=False
+                    entity_type="chat",
+                    check_type=False,
+                    add_msg=error_msg,
                 )
-                if not chat_id:
-                    self.logger.error("Failed to get chat ID from forwarded message")
-                    return False
-                while chat_id == channel_id:
-                    error_msg = (
-                        "Chat ID and channel ID are the same. The problem may be that "
-                        "you posted a message in the channel, not in the discussion group."
-                    )
-                    self.logger.error(error_msg)
-                    chat_id = self.wait_for_forwarded_message(
-                        entity_type="chat",
-                        check_type=False,
-                        add_msg=error_msg,
-                    )
-                if chat_id:
-                    self.save_username(chat_result, chat_id)
-        else:
-            raise Exception("Chat ID is undefined")
+            if chat_id:
+                self.save_username(chat_result, chat_id)
 
         if not channel_id:
             raise Exception("Channel ID is undefined")
@@ -1234,14 +1279,15 @@ class TelegramExporter(BaseExporter):
             return None
 
     def verify_access(self, telegram_id, hr_type=None):
-        url = f"https://api.telegram.org/bot{self.bot_token}/getChatAdministrators"
         if not str(telegram_id).startswith("-100"):
             telegram_id = f"-100{telegram_id}"
-        req = requests.post(url, data={"chat_id": telegram_id})
-        if self.args.debug:
-            print(req.status_code, req.text)
-        if req.status_code != 200:
-            raise Exception(f"Bot isn't added to {hr_type}")
-        obj = req.json()
-        admin_ids = {x["user"]["id"] for x in obj["result"]}
-        return self.bot_id in admin_ids
+        try:
+            result = self.send_api_request(
+                "getChatAdministrators", {"chat_id": telegram_id}
+            )
+            if self.args.debug:
+                print(f"getChatAdministrators result: {result}")
+            admin_ids = {x["user"]["id"] for x in result}
+            return self.bot_id in admin_ids
+        except Exception as e:
+            raise Exception(f"Bot isn't added to {hr_type}: {e}")

{chgksuite-0.27.2 → chgksuite-0.28.0}/chgksuite/parser.py

@@ -38,7 +38,6 @@ from chgksuite.common import (
     init_logger,
     load_settings,
     log_wrap,
-    read_text_file,
     set_lastdir,
 )
 from chgksuite.composer import gui_compose

chgksuite-0.28.0/chgksuite/version.py

@@ -0,0 +1 @@
+__version__ = "0.28.0"

{chgksuite-0.27.2 → chgksuite-0.28.0}/pyproject.toml

@@ -54,7 +54,11 @@ chgksuite = "chgksuite.__main__:main"
 path = "chgksuite/version.py"
 
 [tool.hatch.build.targets.sdist]
-exclude = [".venv*"]
+include = [
+    "chgksuite/**/*",
+    "/LICENSE",
+    "/README.md",
+]
 
 [tool.hatch.build.targets.wheel]
 packages = ["chgksuite"]

chgksuite-0.27.2/.claude/settings.local.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(uv run pytest:*)",
-      "Bash(ls:*)",
-      "Bash(python3:*)",
-      "Bash(mv:*)"
-    ]
-  }
-}

chgksuite-0.27.2/.github/workflows/build.yml

@@ -1,283 +0,0 @@
-name: Build Standalone Executables
-
-on:
-  push:
-    tags:
-      - 'v*'
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: 'Tag to build and release (e.g., v0.26.1). Leave empty for build-only.'
-        required: false
-        default: ''
-
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-24.04
-            platform: linux-x64
-            rust_target: x86_64-unknown-linux-gnu
-          - os: ubuntu-24.04-arm
-            platform: linux-arm64
-            rust_target: aarch64-unknown-linux-gnu
-          - os: macos-15-intel
-            platform: macos-x64
-            rust_target: x86_64-apple-darwin
-          - os: macos-latest
-            platform: macos-arm64
-            rust_target: aarch64-apple-darwin
-          - os: windows-latest
-            platform: windows-x64
-            rust_target: x86_64-pc-windows-msvc
-
-    runs-on: ${{ matrix.os }}
-
-    steps:
-      - name: Checkout chgksuite
-        uses: actions/checkout@v4
-
-      - name: Checkout pyapp
-        uses: actions/checkout@v4
-        with:
-          repository: ofek/pyapp
-          path: pyapp
-          ref: v0.29.0
-
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.rust_target }}
-
-      - name: Create build directory
-        shell: bash
-        run: mkdir -p artifacts
-
-      # Determine versions and create requirements files
-      - name: Setup build configuration
-        id: config
-        shell: bash
-        run: |
-          TAG="${{ inputs.tag || github.ref_name }}"
-
-          # Check if this is a release build (tag) or dev build (branch)
-          IS_RELEASE="false"
-          if [[ "${{ github.ref }}" == refs/tags/* ]] || [[ -n "${{ inputs.tag }}" ]]; then
-            IS_RELEASE="true"
-          fi
-
-          # Extract version from tag (remove 'v' prefix if present)
-          if [[ "$TAG" =~ ^v ]]; then
-            VERSION="${TAG:1}"
-          else
-            VERSION="$TAG"
-          fi
-
-          # Fallback to reading from version.py if no tag
-          if [ -z "$VERSION" ] || [[ ! "$VERSION" =~ ^[0-9] ]]; then
-            VERSION=$(grep -oP '__version__\s*=\s*"\K[^"]+' chgksuite/version.py 2>/dev/null || \
-                      grep -o '__version__\s*=\s*"[^"]*"' chgksuite/version.py | cut -d'"' -f2 || \
-                      echo "0.0.0")
-          fi
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "is_release=$IS_RELEASE" >> $GITHUB_OUTPUT
-
-          # For non-release builds, always use --pre to get latest beta versions
-          if [ "$IS_RELEASE" = "false" ]; then
-            PIP_PRE="--pre"
-          elif [[ "$VERSION" =~ (a|b|rc)[0-9]+ ]]; then
-            PIP_PRE="--pre"
-          else
-            PIP_PRE=""
-          fi
-          echo "pip_pre=$PIP_PRE" >> $GITHUB_OUTPUT
-
-          echo "Build configuration:"
-          echo "  Version: $VERSION"
-          echo "  Is release: $IS_RELEASE"
-          echo "  Pip pre flag: $PIP_PRE"
-
-      # Create requirements files in pyapp directory to avoid Windows path issues
-      - name: Create requirements files
-        shell: bash
-        run: |
-          # Qt requirements
-          echo "chgksuite" > pyapp/requirements-qt.txt
-          echo "chgksuite-qt" >> pyapp/requirements-qt.txt
-
-          # Tk requirements
-          echo "chgksuite" > pyapp/requirements-tk.txt
-          echo "chgksuite-tk" >> pyapp/requirements-tk.txt
-
-          echo "=== Qt requirements ==="
-          cat pyapp/requirements-qt.txt
-          echo "=== Tk requirements ==="
-          cat pyapp/requirements-tk.txt
-
-      # Build Qt GUI (skip on linux-arm64 - no PyQt6 wheel)
-      - name: Build Qt GUI
-        if: matrix.platform != 'linux-arm64'
-        shell: bash
-        working-directory: pyapp
-        run: |
-          export PYAPP_PROJECT_NAME="chgksuite-qt"
-          export PYAPP_PROJECT_VERSION="${{ steps.config.outputs.version }}"
-          export PYAPP_PROJECT_DEPENDENCY_FILE="$(pwd)/requirements-qt.txt"
-          export PYAPP_EXEC_SPEC="chgksuite_qt.__main__:main"
-          export PYAPP_PYTHON_VERSION="3.12"
-          export PYAPP_IS_GUI="1"
-          export PYAPP_UV_ENABLED="1"
-          export PYAPP_PIP_EXTRA_ARGS="${{ steps.config.outputs.pip_pre }}"
-          export PYAPP_PASS_LOCATION="1"
-
-          echo "Building Qt GUI with:"
-          echo "  PYAPP_PROJECT_DEPENDENCY_FILE=$PYAPP_PROJECT_DEPENDENCY_FILE"
-          echo "  PYAPP_PIP_EXTRA_ARGS=$PYAPP_PIP_EXTRA_ARGS"
-
-          cargo build --release --target ${{ matrix.rust_target }}
-
-          # Copy binary with platform-specific naming
-          if [ "${{ runner.os }}" = "Windows" ]; then
-            cp target/${{ matrix.rust_target }}/release/pyapp.exe ../artifacts/chgkq-${{ matrix.platform }}.exe
-          else
-            cp target/${{ matrix.rust_target }}/release/pyapp ../artifacts/chgkq-${{ matrix.platform }}
-          fi
-
-      # Build Tk GUI
-      - name: Build Tk GUI
-        shell: bash
-        working-directory: pyapp
-        run: |
-          export PYAPP_PROJECT_NAME="chgksuite-tk"
-          export PYAPP_PROJECT_VERSION="${{ steps.config.outputs.version }}"
-          export PYAPP_PROJECT_DEPENDENCY_FILE="$(pwd)/requirements-tk.txt"
-          export PYAPP_EXEC_SPEC="chgksuite_tk.__main__:main"
-          export PYAPP_PYTHON_VERSION="3.12"
-          export PYAPP_IS_GUI="1"
-          export PYAPP_UV_ENABLED="1"
-          export PYAPP_PIP_EXTRA_ARGS="${{ steps.config.outputs.pip_pre }}"
-          export PYAPP_PASS_LOCATION="1"
-
-          echo "Building Tk GUI with:"
-          echo "  PYAPP_PROJECT_DEPENDENCY_FILE=$PYAPP_PROJECT_DEPENDENCY_FILE"
-          echo "  PYAPP_PIP_EXTRA_ARGS=$PYAPP_PIP_EXTRA_ARGS"
-
-          cargo build --release --target ${{ matrix.rust_target }}
-
-          # Copy binary with platform-specific naming
-          if [ "${{ runner.os }}" = "Windows" ]; then
-            cp target/${{ matrix.rust_target }}/release/pyapp.exe ../artifacts/chgkt-${{ matrix.platform }}.exe
-          else
-            cp target/${{ matrix.rust_target }}/release/pyapp ../artifacts/chgkt-${{ matrix.platform }}
-          fi
-
-      # Create macOS .app bundles (required for Finder launch)
-      - name: Create macOS app bundles
-        if: runner.os == 'macOS'
-        shell: bash
-        run: |
-          # Create Qt .app bundle
-          if [ -f "artifacts/chgkq-${{ matrix.platform }}" ]; then
-            mkdir -p "artifacts/chgkq.app/Contents/MacOS"
-            mv "artifacts/chgkq-${{ matrix.platform }}" "artifacts/chgkq.app/Contents/MacOS/chgkq"
-            cat > "artifacts/chgkq.app/Contents/Info.plist" << 'EOF'
-          <?xml version="1.0" encoding="UTF-8"?>
-          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-          <plist version="1.0">
-          <dict>
-            <key>CFBundleExecutable</key>
-            <string>chgkq</string>
-            <key>CFBundleIdentifier</key>
-            <string>me.pecheny.chgkq</string>
-            <key>CFBundleName</key>
-            <string>chgksuite-qt</string>
-            <key>CFBundlePackageType</key>
-            <string>APPL</string>
-            <key>CFBundleVersion</key>
-            <string>${{ steps.config.outputs.version }}</string>
-            <key>CFBundleShortVersionString</key>
-            <string>${{ steps.config.outputs.version }}</string>
-            <key>LSMinimumSystemVersion</key>
-            <string>10.15</string>
-            <key>NSHighResolutionCapable</key>
-            <true/>
-          </dict>
-          </plist>
-          EOF
-            # Ad-hoc sign the app bundle to prevent "damaged" error
-            codesign --force --deep --sign - "artifacts/chgkq.app"
-            # Zip the .app bundle
-            cd artifacts && zip -r "chgkq-${{ matrix.platform }}.zip" chgkq.app && rm -rf chgkq.app && cd ..
-          fi
-
-          # Create Tk .app bundle
-          if [ -f "artifacts/chgkt-${{ matrix.platform }}" ]; then
-            mkdir -p "artifacts/chgkt.app/Contents/MacOS"
-            mv "artifacts/chgkt-${{ matrix.platform }}" "artifacts/chgkt.app/Contents/MacOS/chgkt"
-            cat > "artifacts/chgkt.app/Contents/Info.plist" << 'EOF'
-          <?xml version="1.0" encoding="UTF-8"?>
-          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-          <plist version="1.0">
-          <dict>
-            <key>CFBundleExecutable</key>
-            <string>chgkt</string>
-            <key>CFBundleIdentifier</key>
-            <string>me.pecheny.chgkt</string>
-            <key>CFBundleName</key>
-            <string>chgksuite-tk</string>
-            <key>CFBundlePackageType</key>
-            <string>APPL</string>
-            <key>CFBundleVersion</key>
-            <string>${{ steps.config.outputs.version }}</string>
-            <key>CFBundleShortVersionString</key>
-            <string>${{ steps.config.outputs.version }}</string>
-            <key>LSMinimumSystemVersion</key>
-            <string>10.15</string>
-            <key>NSHighResolutionCapable</key>
-            <true/>
-          </dict>
-          </plist>
-          EOF
-            # Ad-hoc sign the app bundle to prevent "damaged" error
-            codesign --force --deep --sign - "artifacts/chgkt.app"
-            # Zip the .app bundle
-            cd artifacts && zip -r "chgkt-${{ matrix.platform }}.zip" chgkt.app && rm -rf chgkt.app && cd ..
-          fi
-
-      - name: List artifacts
-        shell: bash
-        run: ls -lh artifacts/
-
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: builds-${{ matrix.platform }}
-          path: artifacts/*
-
-  release:
-    needs: build
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/') || inputs.tag != ''
-    permissions:
-      contents: write
-
-    steps:
-      - name: Download all artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: artifacts
-          merge-multiple: true
-
-      - name: List artifacts
-        run: ls -la artifacts/
-
-      - name: Create Release
-        uses: softprops/action-gh-release@v1
-        with:
-          tag_name: ${{ inputs.tag || github.ref_name }}
-          files: artifacts/*
-          generate_release_notes: true
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

chgksuite-0.27.2/.gitlab-ci.yml

@@ -1,17 +0,0 @@
-image: python:3.14-trixie
-
-before_script:
-  - pip install zensical
-
-pages:
-  stage: deploy
-  script:
-  - cd docs
-  - zensical build
-  - mv public ../public
-  - cd ..
-  artifacts:
-    paths:
-    - public
-  rules:
-    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH