python-gitea 0.9.0__tar.gz → 0.10.0__tar.gz

{python_gitea-0.9.0 → python_gitea-0.10.0}/.gitignore

@@ -133,3 +133,7 @@ dmypy.json
 
 # Node.js
 node_modules/
+
+# mutmut
+/mutants/
+/.mutmut-cache

{python_gitea-0.9.0 → python_gitea-0.10.0}/CONTRIBUTING.md

@@ -81,6 +81,80 @@ submitting a pull request—this guide will help you get started.
     pytest
     ```
 
+    Mutation testing runs the suite again for each deliberate alteration of the
+    source, and reports the alterations no test noticed:
+
+    ```shell
+    uv run mutmut run                  # every module
+    uv run mutmut run "gitea.cli.*"    # one subtree, while iterating
+    uv run mutmut results              # what survived
+    ```
+
+    A survivor is a change to the code that every test tolerated. Some cannot be
+    killed - a rewritten `typing.cast`, or anything in a `register_commands()`
+    that runs at import time - so read the diff `uv run mutmut show <mutant>`
+    prints before writing a test for one.
+
+    A filter selects which mutants are _run_, not which are written: every module
+    is mutated either way, so a scoped run still reports mutating the whole tree
+    and its progress counter reads `46/9042`, where the denominator counts every
+    mutant written and the numerator counts the ones the filter selected and
+    checked. Take the result of a scoped run from `uv run mutmut results` rather
+    than from that counter: it lists every mutant that was not killed, labelling
+    each as `survived` or as `not checked`, and naming the module it belongs to,
+    so the survivors of a scope are the `survived` entries whose names begin with
+    it. A filter matching no mutant stops the run with an error instead of
+    quietly widening it, so a scoped run that gets as far as testing is one that
+    scoped.
+
+    That listing names no killed mutant, though, so it cannot say how large the
+    scope was or what share of it died. Both are recorded per module, in the
+    `.meta` file mutmut writes beside each mutated module, whose
+    `exit_code_by_key` maps every mutant to the exit code of the run that checked
+    it - `0` survived, `1` killed, `null` never checked. Counting those gives the
+    verdict of a scope, and shows the modules outside it untouched. Point it at
+    the package directory the scope sits in - every module in the tree has a
+    `.meta`, so pointing it at the whole of `src/gitea` prints a line per module:
+
+    ```shell
+    uv run python - <<'PY'
+    import collections, json, pathlib
+
+    status = {0: "survived", 1: "killed", 3: "killed", 5: "no tests", 33: "no tests", None: "not checked"}
+    for meta in sorted(pathlib.Path("mutants/src/gitea/project").glob("*.py.meta")):
+        codes = json.loads(meta.read_text())["exit_code_by_key"]
+        counts = collections.Counter(status.get(c, f"exit {c}") for c in codes.values())
+        if counts:
+            print(f"{meta.name:24} {dict(counts)}")
+    PY
+    ```
+
+    ```text
+    async_project.py.meta    {'killed': 620, 'survived': 16}
+    base.py.meta             {'not checked': 215}
+    project.py.meta          {'killed': 620, 'survived': 16}
+    ```
+
+    That is the output of a run scoped to the two project resource modules: 636
+    mutants each, 1,240 of the 1,272 killed, and the 215 of a module outside the
+    scope sitting unchecked. Start from `rm -rf mutants` when a run has to stand
+    on its own, since the verdicts of one run are otherwise carried into the
+    next.
+
+    To scope what is _written_ as well, and get a counter whose denominator is
+    the scope, point `source_paths` at the modules and let `also_copy` carry the
+    rest of the package that the tests import. Scoped to the same two modules as
+    above, that run reports mutating two files and counts `1272/1272`:
+
+    ```toml
+    [tool.mutmut]
+    source_paths = [
+      "src/gitea/project/project.py",
+      "src/gitea/project/async_project.py",
+    ]
+    also_copy = ["scripts/", "src/"]
+    ```
+
 8. Open a Pull Request
 
     Clearly describe the motivation and scope of your change. Link it to the relevant issue if applicable.

{python_gitea-0.9.0 → python_gitea-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-gitea
-Version: 0.9.0
+Version: 0.10.0
 Summary: A Python package for interacting with the Gitea API, offering a simple interface to access repositories, users, organizations, issues, and more for automation and data management.
 Project-URL: Documentation, https://isaac-cf-wong.github.io/python-gitea
 Project-URL: Source, https://github.com/isaac-cf-wong/python-gitea

{python_gitea-0.9.0 → python_gitea-0.10.0}/docs/dev/architecture.md

@@ -44,6 +44,7 @@ src/gitea/
 ├── milestone/               # Milestone resource (sync + async)
 ├── notification/            # Notification resource (sync + async)
 ├── project/                 # Project resource (sync + async)
+├── organization/            # Organization resource (sync + async)
 ├── cli/                     # Typer CLI application
 │   ├── main.py              # gitea-cli entry point, command registration
 │   ├── config/              # config commands
@@ -54,9 +55,12 @@ src/gitea/
 │   ├── milestone/           # milestone commands
 │   ├── notification/        # notification commands
 │   ├── project/             # project, column, and project-issue commands
+│   ├── organization/        # org commands
+│   ├── repository/          # repo commands
 │   ├── user/                # user commands
 │   └── utils/               # auth resolution, API helpers, conversions
-└── utils/                   # Logging, pagination, and response helpers
+└── utils/                   # Logging, field names, pagination, and response helpers
+    ├── fields.py            # Field-name convention and compatibility aliases
     ├── log.py               # Logger setup
     ├── pagination.py        # Paginated-listing walkers
     └── response.py          # Response processing helpers
@@ -85,6 +89,7 @@ with Gitea(token="...", base_url="...") as client:
     client.milestone      # Milestone
     client.notification   # Notification
     client.project        # Project
+    client.organization   # Organization
 ```
 
 ## Resource Layer

{python_gitea-0.9.0 → python_gitea-0.10.0}/docs/user-guide/cli.md

@@ -65,7 +65,7 @@ command:
 
 - API commands report `status_code`.
 - Commands that page through the API add counts, such as `column_count` and
-  `issue_count` for `project issues`.
+  `issue_count` for `project issues` and `project show`.
 - `config` commands report `config_path`.
 - It is `{}` when the command made no call at all.
 
@@ -81,10 +81,45 @@ failing over an enrichment of it.
 
 Tokens are never included in the output of `config` commands in either format.
 
+## Field names
+
+Every field of `data` is named as the Gitea API names it. Nothing is renamed and
+nothing is dropped on the way out, so a key can be looked up in
+[Gitea's own API reference](https://docs.gitea.com/api/1.24/) rather than in
+this CLI's source, and the same value never arrives under two names depending on
+which command fetched it.
+
+A field the API cannot send is added only where it carries something the API has
+no way of saying, and is documented with the command that adds it: `column_id`
+on the project entries of `issue get`, and `issue_count` and `issue_ids` on the
+columns of `project show`, are the ones today. Such a field is never a second
+name for a field already in the payload.
+
+Two consequences worth knowing:
+
+- A project column is `title`, not `name`:
+
+    ```console
+    $ gitea-cli --output json project column list --owner my-org --project-id 31
+    {
+      "data": [{ "id": 117, "title": "Working", "default": false, "sorting": 0, ... }],
+      "metadata": { "status_code": 200 }
+    }
+    ```
+
+- A field whose name misleads is documented rather than renamed. `comments` on
+  an issue is the _number_ of comments; `gitea-cli issue comment list` reads the
+  bodies.
+
+The Python client follows the same convention and additionally keeps a field
+name callers already wrote readable as an alias - `column["name"]` reads the
+title - which the [Python API guide](python-api.md#field-names) describes. An
+alias is never emitted, so it cannot appear in the JSON above.
+
 ## Option naming
 
-Every resource command addresses its target the same way, so an invocation can
-be written without reading `--help` first:
+Every command that addresses something an account owns names its target the same
+way, so an invocation can be written without reading `--help` first:
 
 | Option          | Meaning                                                  |
 | --------------- | -------------------------------------------------------- |
@@ -123,6 +158,16 @@ are required together because there is no scope for them to fall back to:
 neither `--owner` nor `--repository` it acts on the authenticated user's
 notifications, and the two must be passed together or not at all.
 
+A command whose target is an account rather than something an account owns takes
+no `--owner` at all, and names the account with `--username` instead: `org list`
+lists an account's organizations and `user get` reads an account's profile, both
+answering for the account the token belongs to when `--username` is omitted.
+
+`repo list` is the one command where the _kind_ of owner matters: Gitea serves
+an organization's repositories and a user's at different endpoints, so
+`--owner-type` says which of the two `--owner` names. It defaults to
+`organization`.
+
 ### Deprecated option names
 
 `--index` has been renamed to `--issue-id`, so that one option name means "which
@@ -169,9 +214,11 @@ endpoint to serve it with, so they answer by naming the option to pass.
     - Optional: `--state`, `--labels`, `--search-string`, `--created-by`,
       `--assigned-by`, `--since`, `--before`, `--page`, `--limit`
 - `gitea-cli issue get --owner <owner> --repository <repo> --issue-id <number>`
-    - The `comment_count` field is the number of comments on the issue, not the
+    - The `comments` field is the number of comments on the issue, not the
       comments themselves; use `gitea-cli issue comment list` to read the
-      bodies.
+      bodies. The field keeps the API's name, as
+      [the field-name convention](#field-names) requires: this command used to
+      rename it to `comment_count` and was alone in doing so.
     - Each entry of `projects` carries a `column_id`: the column the issue's
       card sits in, or `null` when the issue has no card on that project. Gitea
       does not report it on the issue itself, so it is resolved from each
@@ -187,6 +234,13 @@ endpoint to serve it with, so they answer by naming the option to pass.
 - `gitea-cli issue edit --owner <owner> --repository <repo> --issue-id <number>`
     - Optional: `--title`, `--body`, `--state`, `--assignees`, `--milestone`,
       `--due-date`
+- `gitea-cli issue close --owner <owner> --repository <repo> --issue-id <number>`
+    - Optional: `--comment`
+    - Closes the issue, which `issue edit --state closed` also does; this is the
+      shorter way to say it and the one that takes a `--comment`.
+    - `--comment` posts that body on the issue after it is closed. The issue is
+      closed first, so a comment that is refused leaves the issue closed rather
+      than the close undone; the result is the closed issue either way.
 - `gitea-cli issue dependency add --owner <owner> --repository <repo> --issue-id <number>`
     - Required: `--dependency-owner <owner>`, `--dependency-repository <repo>`,
       `--dependency-issue-id <number>`
@@ -252,6 +306,8 @@ gitea-cli project list --owner my-org --repository my-repo  # that repository's
     - Optional: `--description`, `--card-type`, `--template-type`
 - `gitea-cli project list --owner <owner> [--repository <repo>]`
 - `gitea-cli project get --owner <owner> [--repository <repo>] --project-id <id>`
+- `gitea-cli project show --owner <owner> [--repository <repo>] --project-id <id>`
+    - Optional: `--full`
 - `gitea-cli project edit --owner <owner> [--repository <repo>] --project-id <id>`
     - Optional: `--title`, `--description`, `--state`, `--card-type`
 - `gitea-cli project delete --owner <owner> [--repository <repo>] --project-id <id>`
@@ -298,6 +354,31 @@ instance is down.
     - Optional: `--full-name`, `--website`, `--location`, `--language`,
       `--theme`, `--diff-view-style`, `--hide-email`, `--hide-activity`
 
+### Org - discover organizations
+
+- `gitea-cli org list`
+    - Optional: `--username`, `--page`, `--limit`
+    - Lists the organizations of the account the token belongs to; `--username`
+      lists those of another account instead.
+    - Gitea also has a site-wide listing of every organization, which a token
+      that is not scoped for it is refused. This command does not read from it,
+      so it answers with the organizations of an account and never with the
+      instance's.
+
+### Repo - discover repositories
+
+- `gitea-cli repo list --owner <owner>`
+    - Optional: `--owner-type`, `--page`, `--limit`
+    - `--owner-type` is `organization` (the default) or `user`: Gitea serves the
+      two at different endpoints - `/orgs/<owner>/repos` and
+      `/users/<owner>/repos` - and an owner's name does not say which of the two
+      it is.
+
+```bash
+gitea-cli repo list --owner my-org                     # an organization's repositories
+gitea-cli repo list --owner alice --owner-type user    # a user's repositories
+```
+
 ### Watch - report what changed since the last run
 
 Every other command answers a question about the instance now. `watch` answers
@@ -486,6 +567,30 @@ Show every card on a project together with the column it is in:
 gitea-cli project issues --owner my-org --project-id 1
 ```
 
+Read a board's shape in one call - the project, its columns, and how many cards
+sit in each of them. `project get` answers with the project alone, which says
+nothing about where the cards are:
+
+```console
+$ gitea-cli --output json project show --owner my-org --project-id 31
+{
+  "data": {
+    "project": { "id": 31, "title": "Board", "state": "open", ... },
+    "columns": [
+      { "id": 117, "title": "Working", ..., "issue_count": 2, "issue_ids": [1873, 1874] }
+    ]
+  },
+  "metadata": { "status_code": 200, "column_count": 1, "issue_count": 2 }
+}
+```
+
+Each column is the columns endpoint's own object with `issue_count` and
+`issue_ids` added to it, and `issue_ids` holds the global issue IDs the project
+endpoints take - `--issue-id` without `--issue-repository`. Add `--full` to have
+each column carry its issues themselves, under `issues`, rather than their IDs
+alone. Every page of columns, and of each column's issues, is walked, so the
+counts describe the whole board.
+
 Report what changed across two repositories and a board since the last run,
 quietly enough to be worth a `cron` entry:
 

{python_gitea-0.9.0 → python_gitea-0.10.0}/docs/user-guide/python-api.md

@@ -126,12 +126,49 @@ is simpler and sufficient.
 | `client.milestone`    | Milestones                            |
 | `client.notification` | Notifications                         |
 | `client.project`      | Projects, columns, and project issues |
+| `client.organization` | Organizations                         |
 
 Each resource is implemented in a synchronous class (e.g. `gitea.issue.Issue`)
 and an async class (e.g. `gitea.issue.AsyncIssue`); some modules re-export them
 from the package `__init__` (e.g. `from gitea.issue import Issue`). See the
 [API Reference](../reference/index.md) for the full method list and signatures.
 
+## Field Names
+
+A payload returned by a client method is the JSON the Gitea API sent, keyed as
+the API keys it. Nothing is renamed and nothing is dropped, in the client
+dictionaries and in [the CLI's JSON envelope](cli.md#field-names) alike, so a
+key is looked up in Gitea's API reference and not in this library's source.
+
+A project column is therefore `title`:
+
+```python
+columns, _ = client.project.list_project_columns(owner="my-org", repository=None, project_id=31)
+print(columns[0]["title"])  # 'Working'
+```
+
+`name` reads it too. It is an alias, not a second key: reading a payload by it
+works, and enumerating or serializing the payload sees `title` alone, so nothing
+downstream can come to depend on a name the API does not use.
+
+```python
+column = columns[0]
+column["name"]        # 'Working' - reads the title
+column.get("name")    # 'Working'
+"name" in column      # True
+list(column)          # ['id', 'title', 'default', 'sorting', ...] - no 'name'
+json.dumps(column)    # {"id": 117, "title": "Working", ...} - no 'name'
+```
+
+Only reading is widened. `column["name"] = x` writes a field called `name`, as
+it would on any dictionary, rather than changing the title through a name Gitea
+does not use.
+
+`gitea.utils.fields` holds the convention itself, the record types declaring the
+aliases of a resource, and the bar an alias has to clear to be added: a name
+callers have written, not a name that reads well. Today there is one, `name` on
+a project column.
+
 ## Detecting What Changed
 
 `gitea.watch` is not a resource: it holds the change detection that

{python_gitea-0.9.0 → python_gitea-0.10.0}/mkdocs.yml

@@ -132,6 +132,11 @@ nav:
                       - Overview: reference/gitea/project/index.md
                       - Project: reference/gitea/project/project.md
                       - Async Project: reference/gitea/project/async_project.md
+                - Organization:
+                      - Overview: reference/gitea/organization/index.md
+                      - Organization: reference/gitea/organization/organization.md
+                      - Async Organization:
+                            reference/gitea/organization/async_organization.md
                 - User:
                       - Overview: reference/gitea/user/index.md
                       - User: reference/gitea/user/user.md

{python_gitea-0.9.0 → python_gitea-0.10.0}/pyproject.toml

@@ -30,6 +30,11 @@ dependencies = [
 [dependency-groups]
 dev = [
   "ruff>=0.16.3",
+  # The mutation runner, in the environment `uv run` resolves, so that
+  # `uv run mutmut run` reaches the same interpreter as `uv run pytest` and finds
+  # the pytest plugins the suite's own options need. Run from a tool environment
+  # of its own it cannot read `--cov`, and the run dies at collection.
+  "mutmut>=3.7.0",
   "prek>=0.4.13",
   "pytest-github-actions-annotate-failures>=0.4.2",
   "pytest-cov>=7.1.0",
@@ -75,6 +80,34 @@ source = "vcs"
 [tool.hatch.build.targets.wheel]
 packages = ["src/gitea"]
 
+[tool.mutmut]
+# The suite imports from `scripts/` (see `pythonpath` under
+# `[tool.pytest.ini_options]`), so the copy of the tree that mutmut runs it from
+# needs that directory as well - without it every mutant is reported as killed by
+# a collection error in `tests/test_release_version.py`.
+source_paths = ["src/gitea/"]
+also_copy = ["scripts/"]
+# mutmut runs the suite against a rewritten copy of each module, in which every
+# mutated function is replaced by a table of its variants. A test reading a module
+# rather than calling it therefore reads the instrumentation rather than the code,
+# and fails for every mutant - a red baseline, which reports every mutant as
+# killed. Two do: one asserts on the *text* of a module, the other enumerates the
+# methods of a class, which the variants are bound to as members of. Both are
+# deselected here, and are run by `pytest` as usual.
+pytest_add_cli_args = [
+  "--deselect",
+  "tests/utils/test_utils_pagination.py::TestEndOfListing::test_the_walkers_decide_nothing_of_their_own",
+  "--deselect",
+  "tests/project/test_project_requests.py::test_every_project_method_is_declared",
+]
+# A mutant is judged to hang when its tests exceed `timeout_multiplier` times what
+# they took clean, plus this constant. Most tests here take a millisecond or two,
+# so the default constant of one second leaves a budget an unmutated run can miss
+# on a loaded machine - and a mutant reported as a timeout has no verdict at all:
+# it is not known to be caught, and it is not reported as surviving either. Ten
+# seconds is still far below anything a real hang would finish in.
+timeout_constant = 10.0
+
 [tool.coverage.run]
 branch = true
 

python_gitea-0.10.0/src/gitea/cli/issue/close.py

@@ -0,0 +1,106 @@
+"""Close issues command."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from gitea.cli.utils.options import DEPRECATED_INDEX_HELP, ISSUE_ID_HELP, REPOSITORY_REQUIRED_HELP
+
+
+def close_command(
+    ctx: typer.Context,
+    owner: Annotated[str, typer.Option("--owner", help="Owner of the repository.")],
+    repository: Annotated[str | None, typer.Option("--repository", help=REPOSITORY_REQUIRED_HELP)] = None,
+    issue_id: Annotated[int | None, typer.Option("--issue-id", help=ISSUE_ID_HELP)] = None,
+    index: Annotated[int | None, typer.Option("--index", help=DEPRECATED_INDEX_HELP, hidden=True)] = None,
+    comment: Annotated[
+        str | None,
+        typer.Option("--comment", help="Body of a comment to post on the issue as it is closed."),
+    ] = None,
+    account_name: Annotated[
+        str | None,
+        typer.Option(
+            "--account-name",
+            help="Name of the account to use for authentication.",
+        ),
+    ] = None,
+    token: Annotated[
+        str | None,
+        typer.Option(
+            "--token",
+            help="Token for authentication. If not provided, the token from the specified account will be used.",
+        ),
+    ] = None,
+    base_url: Annotated[
+        str | None,
+        typer.Option(
+            "--base-url",
+            help="Base URL of the Gitea platform. If not provided, the base URL from the specified account will be used.",
+        ),
+    ] = None,
+) -> None:
+    """Close an issue in a repository.
+
+    Args:
+        ctx: The Typer context.
+        owner: The owner of the repository.
+        repository: The name of the repository, which this command requires.
+        issue_id: The issue number shown in the web UI.
+        index: The deprecated name of `issue_id`.
+        comment: The body of a comment to post on the issue as it is closed. No
+            comment is posted when it is omitted.
+        account_name: Name of the account to use for authentication.
+        token: Token for authentication. If not provided, the token from the specified account will be used.
+        base_url: Base URL of the Gitea platform. If not provided, the base URL from the specified account will be used.
+
+    """
+    from typing import Any  # noqa: PLC0415
+
+    from gitea.cli.utils.api import execute_api_command  # noqa: PLC0415
+    from gitea.cli.utils.auth import get_auth_params  # noqa: PLC0415
+    from gitea.cli.utils.options import require_repository, resolve_issue_id  # noqa: PLC0415
+    from gitea.client.gitea import Gitea  # noqa: PLC0415
+
+    token, base_url = get_auth_params(
+        config_path=ctx.obj.get("config_path"),
+        account_name=account_name,
+        token=token,
+        base_url=base_url,
+    )
+
+    def api_call() -> tuple[dict[str, Any] | list[dict[str, Any]], dict[str, Any]]:
+        """Close the issue, and comment on it when a comment was given.
+
+        The issue is closed before the comment is posted, so a comment that
+        cannot be posted leaves the issue closed rather than leaving the close
+        undone. The result is the closed issue: the comment is what the command
+        does on the way past, not what it was asked for.
+
+        Returns:
+            A tuple containing the issue data and metadata.
+
+        """
+        target_repository = require_repository(repository, command="gitea-cli issue close")
+        target_issue = resolve_issue_id(issue_id=issue_id, index=index, command="gitea-cli issue close")
+
+        with Gitea(token=token, base_url=base_url) as client:
+            closed = client.issue.edit_issue(
+                owner=owner,
+                repository=target_repository,
+                index=target_issue,
+                state="closed",
+            )
+
+            if comment is not None:
+                client.comment.create_comment(
+                    owner=owner,
+                    repository=target_repository,
+                    index=target_issue,
+                    body=comment,
+                )
+
+            return closed
+
+    execute_api_command(api_call=api_call, base_url=base_url, command_name="gitea-cli issue close")

{python_gitea-0.9.0 → python_gitea-0.10.0}/src/gitea/cli/issue/get.py

@@ -1,4 +1,13 @@
-"""Get issues command."""
+"""Get issues command.
+
+The issue is emitted with the field names the API sends, as `gitea.utils.fields`
+requires. `comments` is one worth knowing about: it is the *number* of comments
+on the issue and not their bodies, which `gitea-cli issue comment list` is for.
+An earlier version of this command renamed it to `comment_count` to say so, and
+was the only command emitting an issue that did - the same count arrived under
+two names depending on which command fetched the issue, which was the worse
+surprise of the two.
+"""
 
 from __future__ import annotations
 
@@ -9,26 +18,6 @@ import typer
 from gitea.cli.utils.options import DEPRECATED_INDEX_HELP, ISSUE_ID_HELP, REPOSITORY_REQUIRED_HELP
 
 
-def rename_comment_count(issue: dict[str, Any]) -> dict[str, Any]:
-    """Rename the ``comments`` field of an issue to ``comment_count``.
-
-    The Gitea API returns ``comments`` as an integer count rather than the list of
-    comments, which misleads consumers expecting comment bodies. The value is kept
-    as-is; only the name is made unambiguous. Use ``gitea-cli issue comment list``
-    (or ``gitea-cli comment list``) to retrieve the comments themselves.
-
-    Args:
-        issue: The issue data returned by the API.
-
-    Returns:
-        The issue data with ``comments`` renamed to ``comment_count``.
-
-    """
-    if "comments" not in issue:
-        return issue
-    return {("comment_count" if key == "comments" else key): value for key, value in issue.items()}
-
-
 def get_command(
     ctx: typer.Context,
     owner: Annotated[str, typer.Option("--owner", help="Owner of the repository.")],
@@ -104,6 +93,6 @@ def get_command(
                 index=target_issue,
             )
             data = resolve_project_column_ids(client=client, owner=owner, repository=target_repository, issue=data)
-        return rename_comment_count(data), metadata
+        return data, metadata
 
     execute_api_command(api_call=api_call, base_url=base_url, command_name="gitea-cli issue get")

{python_gitea-0.9.0 → python_gitea-0.10.0}/src/gitea/cli/issue/main.py

@@ -14,12 +14,14 @@ issue_app = typer.Typer(
 def register_commands() -> None:
     """Register issue-related commands to the issue_app."""
     from gitea.cli.comment.main import comment_app  # noqa: PLC0415
+    from gitea.cli.issue.close import close_command  # noqa: PLC0415
     from gitea.cli.issue.create import create_command  # noqa: PLC0415
     from gitea.cli.issue.dependency.main import dependency_app  # noqa: PLC0415
     from gitea.cli.issue.edit import edit_command  # noqa: PLC0415
     from gitea.cli.issue.get import get_command  # noqa: PLC0415
     from gitea.cli.issue.list import list_command  # noqa: PLC0415
 
+    issue_app.command("close", help="Close an issue.")(close_command)
     issue_app.command("create", help="Create an issue.")(create_command)
     issue_app.command("edit", help="Edit an issue.")(edit_command)
     issue_app.command("get", help="Get an issue.")(get_command)

{python_gitea-0.9.0 → python_gitea-0.10.0}/src/gitea/cli/main.py

@@ -147,8 +147,10 @@ def register_commands() -> None:
     from gitea.cli.label.main import label_app  # noqa: PLC0415
     from gitea.cli.milestone.main import milestone_app  # noqa: PLC0415
     from gitea.cli.notification.main import notification_app  # noqa: PLC0415
+    from gitea.cli.organization.main import organization_app  # noqa: PLC0415
     from gitea.cli.project.main import project_app  # noqa: PLC0415
     from gitea.cli.pull_request.main import pull_request_app  # noqa: PLC0415
+    from gitea.cli.repository.main import repository_app  # noqa: PLC0415
     from gitea.cli.user.main import user_app  # noqa: PLC0415
     from gitea.cli.watch.main import watch_app  # noqa: PLC0415
 
@@ -161,6 +163,8 @@ def register_commands() -> None:
     app.add_typer(milestone_app, name="milestone", help="Commands for managing milestones.")
     app.add_typer(notification_app, name="notification", help="Commands for managing notifications.")
     app.add_typer(project_app, name="project", help="Commands for managing projects.")
+    app.add_typer(organization_app, name="org", help="Commands for managing organizations.")
+    app.add_typer(repository_app, name="repo", help="Commands for managing repositories.")
     app.add_typer(watch_app, name="watch", help="Commands for watching issues for changes.")
 
 

python_gitea-0.10.0/src/gitea/cli/organization/__init__.py

@@ -0,0 +1 @@
+"""Command line interface for organizations."""