gitea.project.async_project

async_project

Asynchronous Gitea Project resource.

Classes

gitea.project.async_project.AsyncProject

AsyncProject(client: AsyncClientProtocol)

Bases: BaseProject, AsyncResource

Asynchronous Gitea Project resource.

Source code in src/gitea/resource/async_resource.py

def __init__(self, client: AsyncClientProtocol) -> None:
    """Initialize the Resource with a AsyncGitea client.

    Args:
        client: An instance of the AsyncGitea client.

    """
    self.client = client

Methods:

gitea.project.async_project.AsyncProject.list_projects async

list_projects(
    owner: str,
    repository: str | None,
    state: Literal["open", "closed", "all"] | None = None,
    page: int | None = None,
    limit: int | None = None,
    **kwargs: Any,
) -> tuple[list[dict[str, Any]], dict[str, Any]]

List projects.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
state	Literal['open', 'closed', 'all'] | None	Filter projects by state.	None
page	int | None	The page number for pagination.	None
limit	int | None	The number of projects per page.	None
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[list[dict[str, Any]], dict[str, Any]]	A tuple containing a list of projects as dictionaries and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def list_projects(
    self,
    owner: str,
    repository: str | None,
    state: Literal["open", "closed", "all"] | None = None,
    page: int | None = None,
    limit: int | None = None,
    **kwargs: Any,
) -> tuple[list[dict[str, Any]], dict[str, Any]]:
    """List projects.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        state: Filter projects by state.
        page: The page number for pagination.
        limit: The number of projects per page.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing a list of projects as dictionaries and a dictionary with metadata.

    """
    response = await self._list_projects(
        owner=owner,
        repository=repository,
        state=state,
        page=page,
        limit=limit,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default=[])
    return cast(list[dict[str, Any]], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.get_project async

get_project(
    owner: str,
    repository: str | None,
    project_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Get a project.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[dict[str, Any], dict[str, Any]]	A tuple containing the project as a dictionary and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def get_project(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Get a project.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the project as a dictionary and a dictionary with metadata.

    """
    response = await self._get_project(
        owner=owner,
        repository=repository,
        project_id=project_id,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.create_project async

create_project(
    owner: str,
    repository: str | None,
    title: str,
    description: str | None = None,
    template_type: str | None = None,
    card_type: str | None = None,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Create a project.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
title	str	The title of the project.	required
description	str | None	The description of the project.	None
template_type	str | None	The template type of the project.	None
card_type	str | None	The card type of the project.	None
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[dict[str, Any], dict[str, Any]]	A tuple containing the created project as a dictionary and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def create_project(
    self,
    owner: str,
    repository: str | None,
    title: str,
    description: str | None = None,
    template_type: str | None = None,
    card_type: str | None = None,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Create a project.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        title: The title of the project.
        description: The description of the project.
        template_type: The template type of the project.
        card_type: The card type of the project.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the created project as a dictionary and a dictionary with metadata.

    """
    response = await self._create_project(
        owner=owner,
        repository=repository,
        title=title,
        description=description,
        template_type=template_type,
        card_type=card_type,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.edit_project async

edit_project(
    owner: str,
    repository: str | None,
    project_id: int,
    title: str | None = None,
    description: str | None = None,
    card_type: str | None = None,
    state: Literal["open", "closed"] | None = None,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Edit a project.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
title	str | None	The title of the project.	None
description	str | None	The description of the project.	None
card_type	str | None	The card type of the project.	None
state	Literal['open', 'closed'] | None	The state of the project.	None
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[dict[str, Any], dict[str, Any]]	A tuple containing the edited project as a dictionary and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def edit_project(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    title: str | None = None,
    description: str | None = None,
    card_type: str | None = None,
    state: Literal["open", "closed"] | None = None,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Edit a project.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        title: The title of the project.
        description: The description of the project.
        card_type: The card type of the project.
        state: The state of the project.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the edited project as a dictionary and a dictionary with metadata.

    """
    response = await self._edit_project(
        owner=owner,
        repository=repository,
        project_id=project_id,
        title=title,
        description=description,
        card_type=card_type,
        state=state,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.delete_project async

delete_project(
    owner: str,
    repository: str | None,
    project_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Delete a project.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[dict[str, Any], dict[str, Any]]	A tuple containing the response as a dictionary and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def delete_project(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Delete a project.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the response as a dictionary and a dictionary with metadata.

    """
    response = await self._delete_project(
        owner=owner,
        repository=repository,
        project_id=project_id,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.list_project_columns async

list_project_columns(
    owner: str,
    repository: str | None,
    project_id: int,
    page: int | None = None,
    limit: int | None = None,
    **kwargs: Any,
) -> tuple[list[dict[str, Any]], dict[str, Any]]

List a project's columns.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
page	int | None	The page number for pagination.	None
limit	int | None	The number of columns per page.	None
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
list[dict[str, Any]]	A tuple containing a list of columns as dictionaries and a dictionary with metadata.
dict[str, Any]	A column is keyed as the API keys it - title, not name - and reads name as an alias of
tuple[list[dict[str, Any]], dict[str, Any]]	title, as gitea.utils.fields describes.

Source code in src/gitea/project/async_project.py

async def list_project_columns(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    page: int | None = None,
    limit: int | None = None,
    **kwargs: Any,
) -> tuple[list[dict[str, Any]], dict[str, Any]]:
    """List a project's columns.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        page: The page number for pagination.
        limit: The number of columns per page.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing a list of columns as dictionaries and a dictionary with metadata.
        A column is keyed as the API keys it - `title`, not `name` - and reads `name` as an alias of
        `title`, as `gitea.utils.fields` describes.

    """
    response = await self._list_project_columns(
        owner=owner,
        repository=repository,
        project_id=project_id,
        page=page,
        limit=limit,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default=[])
    return cast(list[dict[str, Any]], as_records(data, ProjectColumn)), {"status_code": status_code}

gitea.project.async_project.AsyncProject.create_project_column async

create_project_column(
    owner: str,
    repository: str | None,
    project_id: int,
    title: str,
    color: str | None = None,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Create a column in a project.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
title	str	The title of the column.	required
color	str | None	The color of the column in 6-digit hex format.	None
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
dict[str, Any]	A tuple containing the created column as a dictionary and a dictionary with metadata.
dict[str, Any]	A column is keyed as the API keys it - title, not name - and reads name as an alias of
tuple[dict[str, Any], dict[str, Any]]	title, as gitea.utils.fields describes.

Source code in src/gitea/project/async_project.py

async def create_project_column(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    title: str,
    color: str | None = None,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Create a column in a project.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        title: The title of the column.
        color: The color of the column in 6-digit hex format.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the created column as a dictionary and a dictionary with metadata.
        A column is keyed as the API keys it - `title`, not `name` - and reads `name` as an alias of
        `title`, as `gitea.utils.fields` describes.

    """
    response = await self._create_project_column(
        owner=owner,
        repository=repository,
        project_id=project_id,
        title=title,
        color=color,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], as_records(data, ProjectColumn)), {"status_code": status_code}

gitea.project.async_project.AsyncProject.get_project_column async

get_project_column(
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Get a project column.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
column_id	int	The ID of the column.	required
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
dict[str, Any]	A tuple containing the column as a dictionary and a dictionary with metadata.
dict[str, Any]	A column is keyed as the API keys it - title, not name - and reads name as an alias of
tuple[dict[str, Any], dict[str, Any]]	title, as gitea.utils.fields describes.

Source code in src/gitea/project/async_project.py

async def get_project_column(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Get a project column.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        column_id: The ID of the column.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the column as a dictionary and a dictionary with metadata.
        A column is keyed as the API keys it - `title`, not `name` - and reads `name` as an alias of
        `title`, as `gitea.utils.fields` describes.

    """
    response = await self._get_project_column(
        owner=owner,
        repository=repository,
        project_id=project_id,
        column_id=column_id,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], as_records(data, ProjectColumn)), {"status_code": status_code}

gitea.project.async_project.AsyncProject.edit_project_column async

edit_project_column(
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    title: str | None = None,
    color: str | None = None,
    sorting: int | None = None,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Edit a project column.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
column_id	int	The ID of the column.	required
title	str | None	The title of the column.	None
color	str | None	The color of the column in 6-digit hex format.	None
sorting	int | None	The position of the column within the project.	None
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
dict[str, Any]	A tuple containing the edited column as a dictionary and a dictionary with metadata.
dict[str, Any]	A column is keyed as the API keys it - title, not name - and reads name as an alias of
tuple[dict[str, Any], dict[str, Any]]	title, as gitea.utils.fields describes.

Source code in src/gitea/project/async_project.py

async def edit_project_column(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    title: str | None = None,
    color: str | None = None,
    sorting: int | None = None,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Edit a project column.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        column_id: The ID of the column.
        title: The title of the column.
        color: The color of the column in 6-digit hex format.
        sorting: The position of the column within the project.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the edited column as a dictionary and a dictionary with metadata.
        A column is keyed as the API keys it - `title`, not `name` - and reads `name` as an alias of
        `title`, as `gitea.utils.fields` describes.

    """
    response = await self._edit_project_column(
        owner=owner,
        repository=repository,
        project_id=project_id,
        column_id=column_id,
        title=title,
        color=color,
        sorting=sorting,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], as_records(data, ProjectColumn)), {"status_code": status_code}

gitea.project.async_project.AsyncProject.delete_project_column async

delete_project_column(
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Delete a project column.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
column_id	int	The ID of the column.	required
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[dict[str, Any], dict[str, Any]]	A tuple containing the response as a dictionary and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def delete_project_column(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Delete a project column.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        column_id: The ID of the column.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the response as a dictionary and a dictionary with metadata.

    """
    response = await self._delete_project_column(
        owner=owner,
        repository=repository,
        project_id=project_id,
        column_id=column_id,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.set_default_project_column async

set_default_project_column(
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Set a project's default column.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
column_id	int	The ID of the column.	required
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[dict[str, Any], dict[str, Any]]	A tuple containing the response as a dictionary and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def set_default_project_column(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Set a project's default column.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        column_id: The ID of the column.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the response as a dictionary and a dictionary with metadata.

    """
    response = await self._set_default_project_column(
        owner=owner,
        repository=repository,
        project_id=project_id,
        column_id=column_id,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.move_project_columns async

move_project_columns(
    owner: str,
    repository: str | None,
    project_id: int,
    column_ids: list[int],
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Reorder a project's columns.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
column_ids	list[int]	Every column ID of the project, in the desired left-to-right order.	required
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[dict[str, Any], dict[str, Any]]	A tuple containing the response as a dictionary and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def move_project_columns(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    column_ids: list[int],
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Reorder a project's columns.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        column_ids: Every column ID of the project, in the desired left-to-right order.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the response as a dictionary and a dictionary with metadata.

    """
    response = await self._move_project_columns(
        owner=owner,
        repository=repository,
        project_id=project_id,
        column_ids=column_ids,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.list_project_column_issues async

list_project_column_issues(
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    page: int | None = None,
    limit: int | None = None,
    **kwargs: Any,
) -> tuple[list[dict[str, Any]], dict[str, Any]]

List the issues in a project column.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
column_id	int	The ID of the column.	required
page	int | None	The page number for pagination.	None
limit	int | None	The number of issues per page.	None
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[list[dict[str, Any]], dict[str, Any]]	A tuple containing a list of issues as dictionaries and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def list_project_column_issues(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    page: int | None = None,
    limit: int | None = None,
    **kwargs: Any,
) -> tuple[list[dict[str, Any]], dict[str, Any]]:
    """List the issues in a project column.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        column_id: The ID of the column.
        page: The page number for pagination.
        limit: The number of issues per page.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing a list of issues as dictionaries and a dictionary with metadata.

    """
    response = await self._list_project_column_issues(
        owner=owner,
        repository=repository,
        project_id=project_id,
        column_id=column_id,
        page=page,
        limit=limit,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default=[])
    return cast(list[dict[str, Any]], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.add_issue_to_project_column async

add_issue_to_project_column(
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    issue_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Add an issue to a project column.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
column_id	int	The ID of the column.	required
issue_id	int	The ID of the issue.	required
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[dict[str, Any], dict[str, Any]]	A tuple containing the response as a dictionary and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def add_issue_to_project_column(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    issue_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Add an issue to a project column.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        column_id: The ID of the column.
        issue_id: The ID of the issue.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the response as a dictionary and a dictionary with metadata.

    """
    response = await self._add_issue_to_project_column(
        owner=owner,
        repository=repository,
        project_id=project_id,
        column_id=column_id,
        issue_id=issue_id,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.remove_issue_from_project_column async

remove_issue_from_project_column(
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    issue_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Remove an issue from a project column.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
column_id	int	The ID of the column.	required
issue_id	int	The ID of the issue.	required
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[dict[str, Any], dict[str, Any]]	A tuple containing the response as a dictionary and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def remove_issue_from_project_column(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    column_id: int,
    issue_id: int,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Remove an issue from a project column.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        column_id: The ID of the column.
        issue_id: The ID of the issue.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the response as a dictionary and a dictionary with metadata.

    """
    response = await self._remove_issue_from_project_column(
        owner=owner,
        repository=repository,
        project_id=project_id,
        column_id=column_id,
        issue_id=issue_id,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], data), {"status_code": status_code}

gitea.project.async_project.AsyncProject.move_project_issue async

move_project_issue(
    owner: str,
    repository: str | None,
    project_id: int,
    issue_id: int,
    column_id: int,
    sorting: int | None = None,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]

Move an issue between a project's columns.

Parameters:

Name	Type	Description	Default
owner	str	The owner of the repository.	required
repository	str | None	The name of the repository, or None for organization projects.	required
project_id	int	The ID of the project.	required
issue_id	int	The ID of the issue.	required
column_id	int	The target column ID.	required
sorting	int | None	The position within the column, ascending.	None
**kwargs	Any	Additional arguments for the request.	{}

Returns:

Type	Description
tuple[dict[str, Any], dict[str, Any]]	A tuple containing the response as a dictionary and a dictionary with metadata.

Source code in src/gitea/project/async_project.py

async def move_project_issue(
    self,
    owner: str,
    repository: str | None,
    project_id: int,
    issue_id: int,
    column_id: int,
    sorting: int | None = None,
    **kwargs: Any,
) -> tuple[dict[str, Any], dict[str, Any]]:
    """Move an issue between a project's columns.

    Args:
        owner: The owner of the repository.
        repository: The name of the repository, or None for organization projects.
        project_id: The ID of the project.
        issue_id: The ID of the issue.
        column_id: The target column ID.
        sorting: The position within the column, ascending.
        **kwargs: Additional arguments for the request.

    Returns:
        A tuple containing the response as a dictionary and a dictionary with metadata.

    """
    response = await self._move_project_issue(
        owner=owner,
        repository=repository,
        project_id=project_id,
        issue_id=issue_id,
        column_id=column_id,
        sorting=sorting,
        **kwargs,
    )
    data, status_code = await process_async_response(response, default={})
    return cast(dict[str, Any], data), {"status_code": status_code}

Functions: