pkgdepends

https://r-lib.github.io/pkgdepends/
Admin
pkgdepends is an R toolkit for managing package dependencies, downloads, and installations,...
Tokens:50,256
Snippets:523
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example: Full Package Installation Workflow

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Demonstrates a complete workflow including resolving, solving, downloading, and getting the installation plan for packages. This example shows how to chain multiple methods together.

```r
pdi <- new_pkg_installation_proposal(
  c("r-lib/pak", "cran::pak"),
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$download()
pdi$get_downloads()
```

--------------------------------

### Install Package with Dependencies

Source: https://r-lib.github.io/pkgdepends/index.html

Create an installation proposal for 'r-lib/cli', configure the library path, then solve, download, and install the package and its dependencies. This example uses a temporary directory for installation.

```r
lib <- tempfile()
dir.create(lib)
pdi <- new_pkg_installation_proposal(
  "r-lib/cli",
  config = list(library = lib)
)
pdi$solve()
pdi$download()
pdi$install()
```

--------------------------------

### Get Installation Plan

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Retrieves the detailed installation plan for the packages. This plan outlines the steps and dependencies for installation.

```r
pdi <- new_pkg_installation_proposal(
  "pak",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$download()
pdi$get_install_plan()
```

--------------------------------

### View First 10 Installed System Packages

Source: https://r-lib.github.io/pkgdepends/reference/sysreqs_list_system_packages.html

This example shows how to display the first 10 rows of the data frame returned by `sysreqs_list_system_packages()`, providing a glimpse of the installed packages and their details.

```r
sysreqs_list_system_packages()[1:10,]
```

--------------------------------

### install()

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Install the downloaded packages. It calls install_package_plan().

```APIDOC
## Method `install()`

### Description
Install the downloaded packages. It calls `install_package_plan()`.

### Usage
```r
pkg_installation_proposal$install()
```

### Returns
The return value of `install_package_plan()`.

```

--------------------------------

### Create and Resolve Package Installation Plan

Source: https://r-lib.github.io/pkgdepends/reference/install_plans.html

Demonstrates the process of creating a new package installation proposal, resolving its dependencies, downloading necessary files, and retrieving the final installation plan. This is useful for setting up a reproducible package installation environment.

```r
if (FALSE) { # \dontrun{
pdi <- new_pkg_installation_proposal(
  "pak",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$download()
pdi$get_install_plan()
} # }
```

--------------------------------

### Create and Resolve Package Installation Proposal

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Initializes a new package installation proposal and resolves its dependencies. Use this to start the process of planning package installations.

```r
if (FALSE) { # \dontrun{
pdi <- new_pkg_installation_proposal(
  "r-lib/pkgdepends",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$get_resolution()
} # }
```

--------------------------------

### Get Configuration

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Retrieves the current configuration settings for the package installation proposal.

```r
pdi$get_config()

```

--------------------------------

### Example: Installed Package Reference Regex

Source: https://r-lib.github.io/pkgdepends/reference/pkg_rx.html

This regex matches references to locally installed packages, specifying the library path and package name.

```R
pkg_rx()$type_installed
```

--------------------------------

### Show Package Installation Solution

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Displays the solved installation plan in a human-readable format. Useful for visual inspection of the proposed installations.

```r
if (FALSE) { # \dontrun{
pdi <- new_pkg_installation_proposal(
  "r-lib/pkgdepends",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$get_solution()
pdi$show_solution()
} # }
```

--------------------------------

### get_install_plan()

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Get the installation plan for the downloaded packages.

```APIDOC
## Method `get_install_plan()`

### Description
Get the installation plan for the downloaded packages.

### Usage
```r
pkg_installation_proposal$get_install_plan()
```

### Returns
An installation plan, see 'Installation plans' for the format.

### Examples
```r

# Example usage (assuming pdi is an initialized pkg_installation_proposal object after download)
# pdi$get_install_plan()

```
```

--------------------------------

### Create and Resolve Package Installation Proposal

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Initializes a new package installation proposal and resolves its dependencies. Use this to set up the initial state for package installation.

```r
pdi <- new_pkg_installation_proposal(
  "pak",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$draw()
```

--------------------------------

### Initialize Package Installation Proposal

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Create a new package installation proposal for a specified package. Configuration options, such as the library path, can be provided.

```r
pdi <- new_pkg_installation_proposal(
  "pak",
  config = list(library = tempfile())
)

```

```r
pdi <- new_pkg_installation_proposal(
  "r-lib/pkgdepends",
  config = list(library = tempfile()))

```

```r
pdi <- new_pkg_installation_proposal("r-lib/pkgdepends")

```

```r
pdi <- new_pkg_installation_proposal(
  "pak",
  config = list(library = tempfile())
)

```

```r
pdi <- new_pkg_installation_proposal(
  "r-lib/pkgdepends",
  config = list(library = tempfile())
)

```

```r
pdi <- new_pkg_installation_proposal(
  "r-lib/pkgdepends",
  config = list(library = tempfile())
)

```

```r
# Method print
pdi <- new_pkg_installation_proposal(
  "pak",
  config = list(library = tempfile())
)

```

--------------------------------

### Creating a Package Installation Proposal

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Demonstrates how to create a new package installation proposal for a given package, optionally with a custom configuration.

```APIDOC
## Function: new_pkg_installation_proposal

### Description
Creates a new package installation proposal.

### Usage
```r
new_pkg_installation_proposal(pkg, config = list())
```

### Arguments
* `pkg` (string): The name or reference of the package.
* `config` (list): A list of configuration options for the installation proposal.

### Examples
```r
# Example 1: Basic proposal for 'pak'
if (FALSE) {
  pdi <- new_pkg_installation_proposal(
    "pak",
    config = list(library = tempfile())
  )
  print(pdi)
}

# Example 2: Proposal for a GitHub repository
if (FALSE) {
  pdi <- new_pkg_installation_proposal(
    "r-lib/pkgdepends",
    config = list(library = tempfile())
  )
  print(pdi)
}
```
```

--------------------------------

### pkg_installation_proposal$show_solution

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Displays the solution (installation plan) for the package installation proposal.

```APIDOC
## Method `pkg_installation_proposal$show_solution`

### Description
Displays the solution (installation plan) for the package installation proposal.

### Method
`show_solution()`

### Request Example
```r
pdi <- new_pkg_installation_proposal(
  "r-lib/pkgdepends",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$get_solution()
pdi$show_solution()
```
```

--------------------------------

### Install an Older Version of a Package

Source: https://r-lib.github.io/pkgdepends/articles/pkgdepends-how-to.html

This demonstrates installing a specific older version of a package. It involves creating an installation proposal for the specified version, solving dependencies, downloading, and installing it.

```r
library(pkgdepends)
dir.create(new_lib <- tempfile())
config <- list(library = new_lib)
prop <- new_pkg_installation_proposal("cran/pkgconfig@2.0.2", config = config)
prop$solve()
prop$download()
prop$install()
lib_status(new_lib)
```

```text
#> ℹ No downloads are needed, 1 pkg is cached                                      
#> ✔ Got pkgconfig 2.0.2 (source) (13.22 kB)                                       
#> ℹ Packaging pkgconfig 2.0.2                                                     
#> ✔ Packaged pkgconfig 2.0.2 (485ms)                                              
#> ℹ Building pkgconfig 2.0.2                                                      
#> ✔ Built pkgconfig 2.0.2 (859ms)                                                 
#> ✔ Installed pkgconfig 2.0.2 (github::cran/pkgconfig@d892880) (1s)               
#> ✔ Summary:   1 new  in 1.9s                                                     
#> # A data frame: 1 × 32                                                          
#>   library        package title version license imports suggests needscompilation
#>   <chr>          <chr>   <chr> <chr>   <chr>   <chr>   <chr>    <lgl>           
#> 1 /tmp/RtmpGtAj… pkgcon… Priv… 2.0.2   MIT + … utils   covr, t… FALSE           
#> # ℹ 24 more variables: repository <chr>, remotetype <chr>, remotehost <chr>,    
#> #   remoterepo <chr>, remoteusername <chr>, remotepkgref <chr>,                 
#> #   remoteref <chr>, remotesha <chr>, built <chr>, depends <chr>,               
#> #   linkingto <chr>, enhances <chr>, md5sum <chr>, platform <chr>,              
#> #   priority <chr>, biocviews <chr>, sysreqs <chr>, ref <chr>, type <chr>,      
#> #   status <chr>, rversion <chr>, sources <list>, repotype <chr>, deps <list>   

```

--------------------------------

### new_pkg_installation_proposal

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Creates a new pkg_installation_proposal object. This is the recommended way to start a package installation workflow.

```APIDOC
## Function: new_pkg_installation_proposal

### Description
Creates a new `pkg_installation_proposal` object. The advantage of `new_pkg_installation_proposal()` compared to using the pkg_installation_proposal constructor directly is that it avoids making pkgdepends a build time dependency.

### Usage
```
new_pkg_installation_proposal(refs, config = list(), ...)
```

### Arguments

*   `refs` (Package names or references) - Required. See 'Package references' for the syntax.
*   `config` (named list) - Optional. Configuration options. See 'Configuration'. If it does not include `library`, then `.libPaths()[1]` is added as `library`.
*   `...` - Additional arguments, passed to `pkg_installation_proposal$new()`.

### Value
`new_pkg_installation_proposal()` returns a new `pkg_installation_proposal` object.
```

--------------------------------

### Create installation plan for system requirements

Source: https://r-lib.github.io/pkgdepends/reference/sysreqs_install_plan.html

Use this function to generate an installation plan for packages and their system requirements. Specify the packages to install and optionally configure platform-specific requirements.

```r
sysreqs_install_plan(
  "tidyverse",
  config = list(sysreqs_platform = "ubuntu-22.04")
)
```

--------------------------------

### Install a Package into a New Library

Source: https://r-lib.github.io/pkgdepends/articles/pkgdepends-how-to.html

Use this to install a package into a new, temporary library. It creates a new installation proposal, solves dependencies, downloads, and installs the package, then shows the library status.

```r
library(pkgdepends)
dir.create(new_lib <- tempfile())
prop <- new_pkg_installation_proposal("pkgconfig", config = list(library = new_lib))
prop$solve()
prop$download()
prop$install()
lib_status(new_lib)
```

```text
#> ℹ Getting 1 pkg (6.08 kB)                                                       
#> ✔ Got pkgconfig 2.0.3 (source) (6.08 kB)                                        
#> ℹ Building pkgconfig 2.0.3                                                      
#> ✔ Built pkgconfig 2.0.3 (851ms)                                                 
#> ✔ Installed pkgconfig 2.0.3  (1s)                                               
#> ✔ Summary:   1 new  in 1.9s                                                     
#> # A data frame: 1 × 31                                                          
#>   library        package title version license imports suggests needscompilation
#>   <chr>          <chr>   <chr> <chr>   <chr>   <chr>   <chr>    <lgl>           
#> 1 /tmp/RtmpGtAj… pkgcon… Priv… 2.0.3   MIT + … utils   covr, t… FALSE           
#> # ℹ 23 more variables: repository <chr>, built <chr>, remotetype <chr>,         
#> #   remotepkgref <chr>, remoteref <chr>, remoterepos <chr>,                     
#> #   remotepkgplatform <chr>, remotesha <chr>, depends <chr>, linkingto <chr>,   
#> #   enhances <chr>, md5sum <chr>, platform <chr>, priority <chr>,               
#> #   biocviews <chr>, sysreqs <chr>, ref <chr>, type <chr>, status <chr>,        
#> #   rversion <chr>, sources <list>, repotype <chr>, deps <list>                 

```

--------------------------------

### Solve Installation Plan

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Calculates the final installation plan after dependencies have been resolved. This prepares the proposal for downloading and installing packages.

```r
pdi$solve()

```

```r
pdi$solve()

```

--------------------------------

### Get Package References

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Retrieves the list of package references associated with the installation proposal.

```r
pdi$get_refs()

```

--------------------------------

### Install packages with 'any::' reference

Source: https://r-lib.github.io/pkgdepends/reference/pkg_refs.html

Use 'any::' to install packages from any source, allowing flexibility when a specific version or repository is not critical. This avoids conflicts when installing multiple packages with potentially overlapping dependencies from different sources.

```R
pak::pkg_install(c("any::glue", "r-lib/cli"))
```

--------------------------------

### Solve Package Installation Plan

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

After resolving dependencies, this method solves the installation plan. It's a necessary step before getting the final solution or plan details.

```r
if (FALSE) { # \dontrun{
pdi <- new_pkg_installation_proposal(
  "r-lib/pkgdepends",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$get_solution()
} # }
```

--------------------------------

### pkg_installation_proposal$get_solution

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Retrieves the solution (installation plan) for the package installation proposal.

```APIDOC
## Method `pkg_installation_proposal$get_solution`

### Description
Retrieves the solution (installation plan) for the package installation proposal.

### Method
`get_solution()`

### Request Example
```r
pdi <- new_pkg_installation_proposal(
  "r-lib/pkgdepends",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$get_solution()
```
```

--------------------------------

### sysreqs_install_plan

Source: https://r-lib.github.io/pkgdepends/reference/sysreqs_install_plan.html

Creates an installation plan for system requirements of specified packages.

```APIDOC
## sysreqs_install_plan(refs, upgrade = TRUE, config = list())

### Description
Creates an installation plan for system requirements of specified packages.

### Arguments
* `refs` (Packages to install.)
* `upgrade` (logical, default TRUE) - If TRUE, pkgdepends will choose the latest available versions of packages, instead of preferring binary packages over source packages.
* `config` (list, default list()) - Configuration options. See 'Configuration'. If it does not include `library`, then a temporary library is used, which is equivalent to not assuming any preinstalled packages. Pass `sysreqs_platform` here if you want a different platform than the one R is running on.

### Value
List with entries:
* `os`: character string. Operating system.
* `distribution`: character string. Linux distribution, `NA` if the OS is not Linux.
* `version`: character string. Distribution version, `NA` is the OS is not Linux.
* `pre_install`: character vector. Commands to run before the installation of system packages.
* `install_scripts`: character vector. Commands to run to install the system packages.
* `post_install`: character vector. Commands to run after the installation of system packages.
* `packages`: data frame. Information about the system packages that are needed. It has columns:
    * `sysreq`: string, cross-platform name of the system requirement.
    * `packages`: list column of character vectors. The names of the R packages that have this system requirement.
    * `pre_install`: list column of character vectors. Commands run before the package installation for this system requirement.
    * `system_packages`: list column of character vectors. Names of system packages to install.
    * `post_install`: list column of character vectors. Commands run after the package installation for this system requirement.

### Examples
```R
sysreqs_install_plan(
  "tidyverse",
  config = list(sysreqs_platform = "ubuntu-22.04")
)
#> $os
#> [1] "linux"
#>
#> $distribution
#> [1] "ubuntu"
#>
#> $version
#> [1] "22.04"
#>
#> $pre_install
#> [1] "apt-get -y update"
#>
#> $install_scripts
#> [1] "apt-get -y install libx11-dev libcurl4-openssl-dev libssl-dev cmake make libuv1-dev zlib1g-dev pandoc libfreetype6-dev libjpeg-dev libpng-dev libtiff-dev libwebp-dev libicu-dev libfontconfig1-dev libfribidi-dev libharfbuzz-dev libxml2-dev"
#>
#> $post_install
#> character(0)
#>
#> $packages
#> # A data frame: 18 × 5
#>    sysreq     packages  pre_install system_packages post_install
#>    <chr>      <list>    <chr [0]>   <list>          <list>      
#>  1 cmake      <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#>  2 fontconfig <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#>  3 freetype   <chr [3]> <chr [0]>   <chr [1]>       <chr [0]>   
#>  4 fribidi    <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#>  5 gnumake    <chr [3]> <chr [0]>   <chr [1]>       <chr [0]>   
#>  6 harfbuzz   <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#>  7 libcurl    <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#>  8 libicu     <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#>  9 libjpeg    <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#> 10 libpng     <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#> 11 libtiff    <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#> 12 libuv      <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#> 13 libwebp    <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#> 14 libxml2    <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#> 15 openssl    <chr [2]> <chr [0]>   <chr [1]>       <chr [0]>   
#> 16 pandoc     <chr [3]> <chr [0]>   <chr [1]>       <chr [0]>   
#> 17 x11        <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#> 18 zlib       <chr [1]> <chr [0]>   <chr [1]>       <chr [0]>   
#> 
```
```

--------------------------------

### pkg_installation_proposal$get_install_plan

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Retrieves the detailed installation plan for the packages.

```APIDOC
## Method `pkg_installation_proposal$get_install_plan`

### Description
Retrieves the detailed installation plan for the packages.

### Method
`get_install_plan()`

### Request Example
```r
pdi <- new_pkg_installation_proposal(
  "pak",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$download()
pdi$get_install_plan()
```
```

--------------------------------

### Get configuration options

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Returns the configuration options associated with the pkg_installation_proposal object. Refer to 'Configuration' for details on available options.

```r
pkg_installation_proposal$get_config()
```

--------------------------------

### Format Package Installation Plan

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Use this method to format the package installation plan for display. The `...` argument is not currently used.

```r
pkg_installation_plan$format(...)
```

--------------------------------

### R Platform Examples

Source: https://r-lib.github.io/pkgdepends/reference/default_platforms.html

Demonstrates the output of `current_r_platform()` and `default_platforms()` in a typical R session.

```r
current_r_platform()
#> [1] "x86_64-pc-linux-gnu-ubuntu-24.04"
default_platforms()
#> [1] "x86_64-pc-linux-gnu-ubuntu-24.04"
#> [2] "source"
```

--------------------------------

### Package installation

Source: https://r-lib.github.io/pkgdepends/reference/index.html

Functions for creating and performing package installation plans.

```APIDOC
## install_plans()

### Description
Generate installation plans for packages.

### Method
`install_plans(refs, ...)`

### Endpoint
N/A (R function)

### Parameters
- **refs** (list) - A list of package references.
- **...** - Additional arguments.

### Request Example
```R
plans <- install_plans(list("cran::dplyr"))
print(plans)
```

### Response
#### Success Response
- **plans** (list) - A list of installation plans.
```

```APIDOC
## install_package_plan()

### Description
Perform a package installation plan.

### Method
`install_package_plan(plan, ...)`

### Endpoint
N/A (R function)

### Parameters
- **plan** (list) - The installation plan to execute.
- **...** - Additional arguments.

### Request Example
```R
install_package_plan(plans)
```

### Response
#### Success Response
- **(void)** - Indicates successful execution.
```

```APIDOC
## new_pkg_installation_plan()

### Description
Create a new R6 class for installation from a lock file.

### Method
`new_pkg_installation_plan()`

### Endpoint
N/A (R function)

### Parameters
None

### Request Example
```R
installation_plan <- new_pkg_installation_plan()
print(installation_plan)
```

### Response
#### Success Response
- **installation_plan** (object) - A new pkg_installation_plan object.
```

```APIDOC
## new_pkg_installation_proposal()

### Description
Create a new R6 class for package download and installation.

### Method
`new_pkg_installation_proposal()`

### Endpoint
N/A (R function)

### Parameters
None

### Request Example
```R
installation_proposal <- new_pkg_installation_proposal()
print(installation_proposal)
```

### Response
#### Success Response
- **installation_proposal** (object) - A new pkg_installation_proposal object.
```

--------------------------------

### Download Packages for Installation

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Initiates the download of packages required for the installation plan. After downloading, you can retrieve the list of downloaded files.

```r
if (FALSE) { # \dontrun{
pdi <- new_pkg_installation_proposal(
  c("r-lib/pak", "cran::pak"),
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$download()
pdi$get_downloads()
} # }
```

--------------------------------

### Install Downloaded Packages

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Installs the packages that have been successfully downloaded. This method calls `install_package_plan()` internally.

```r
pkg_installation_proposal$install()
```

--------------------------------

### install_sysreqs()

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Install system requirements. It does nothing if system requirements are turned off. Create an installation plan for the downloaded packages.

```APIDOC
## Method `install_sysreqs()`

### Description
Install system requirements. It does nothing if system requirements are turned off. Create an installation plan for the downloaded packages.

### Usage
```r
pkg_installation_proposal$install_sysreqs()
```

```

--------------------------------

### Download Packages for Installation Proposal

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Downloads all packages required by the installation proposal. It leverages the package cache to avoid redundant downloads. This method is part of the package installation workflow.

```r
pkg_installation_proposal$download()
```

--------------------------------

### Package Installation Proposal Methods

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Details various methods available for a package installation proposal object, including resolving, solving, downloading, and retrieving configuration or references.

```APIDOC
## Method: pkg_installation_proposal$resolve

### Description
Resolves the dependencies for the package installation proposal.

### Usage
```r
pdi$resolve()
```

### Examples
```r
if (FALSE) {
  pdi <- new_pkg_installation_proposal(
    "pak",
    config = list(library = tempfile())
  )
  pdi$resolve()
  print(pdi)
}
```

## Method: pkg_installation_proposal$solve

### Description
Solves the installation plan for the package installation proposal.

### Usage
```r
pdi$solve()
```

### Examples
```r
if (FALSE) {
  pdi <- new_pkg_installation_proposal(
    "pak",
    config = list(library = tempfile())
  )
  pdi$solve()
  print(pdi)
}
```

## Method: pkg_installation_proposal$download

### Description
Downloads the packages required by the installation proposal.

### Usage
```r
pdi$download()
```

### Examples
```r
if (FALSE) {
  pdi <- new_pkg_installation_proposal(
    "pak",
    config = list(library = tempfile())
  )
  pdi$solve() # Ensure the solution is found first
  pdi$download()
  print(pdi)
}
```

## Method: pkg_installation_proposal$get_refs

### Description
Retrieves the list of package references for the proposal.

### Usage
```r
pdi$get_refs()
```

### Examples
```r
if (FALSE) {
  pdi <- new_pkg_installation_proposal(
    "r-lib/pkgdepends",
    config = list(library = tempfile())
  )
  print(pdi$get_refs())
}
```

## Method: pkg_installation_proposal$get_config

### Description
Retrieves the configuration of the package installation proposal.

### Usage
```r
pdi$get_config()
```

### Examples
```r
if (FALSE) {
  pdi <- new_pkg_installation_proposal(
    "pak",
    config = list(library = tempfile())
  )
  print(pdi$get_config())
}
```

## Method: pkg_installation_proposal$get_solve_policy

### Description
Retrieves the current solve policy of the package installation proposal.

### Usage
```r
pdi$get_solve_policy()
```

### Examples
```r
if (FALSE) {
  pdi <- new_pkg_installation_proposal(
    "r-lib/pkgdepends",
    config = list(library = tempfile())
  )
  print(pdi$get_solve_policy())
}
```

## Method: pkg_installation_proposal$set_solve_policy

### Description
Sets the solve policy for the package installation proposal.

### Usage
```r
pdi$set_solve_policy(policy)
```

### Arguments
* `policy` (string): The new solve policy (e.g., "lazy", "upgrade").

### Examples
```r
if (FALSE) {
  pdi <- new_pkg_installation_proposal(
    "r-lib/pkgdepends",
    config = list(library = tempfile())
  )
  pdi$set_solve_policy("upgrade")
  print(pdi$get_solve_policy())
}
```

## Method: pkg_installation_proposal$get_resolution

### Description
Retrieves the resolution details after calling `$resolve()`.

### Usage
```r
pdi$get_resolution()
```

### Examples
```r
if (FALSE) {
  pdi <- new_pkg_installation_proposal(
    "pak",
    config = list(library = tempfile())
  )
  pdi$resolve()
  print(pdi$get_resolution())
}
```
```

--------------------------------

### pkg_installation_proposal$download

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Downloads the necessary package files according to the installation proposal.

```APIDOC
## Method `pkg_installation_proposal$download`

### Description
Downloads the necessary package files according to the installation proposal.

### Method
`download()`

### Request Example
```r
pdi <- new_pkg_installation_proposal(
  c("r-lib/pak", "cran::pak"),
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$download()
pdi$get_downloads()
```
```

--------------------------------

### Draw Package Installation Proposal Graph

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Visualizes the dependency graph of the package installation proposal. This method helps understand the relationships between packages.

```r
if (FALSE) { # \dontrun{
pdi <- new_pkg_installation_proposal(
  "pak",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$draw()
} # }
```

--------------------------------

### Error when solving dependencies for an installation plan

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

The `solve()` method is implemented for installation plans but will always error, as the plan is already solved.

```r
pkg_installation_plan$solve()
```

--------------------------------

### Download Packages

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Downloads the necessary package files according to the solved installation plan. This is a prerequisite for installing the packages.

```r
pdi$download()

```

--------------------------------

### Format Installation Proposal for Printing

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Formats the `pkg_installation_proposal` object for display. This method is typically used internally when printing the object.

```r
pkg_installation_proposal$format(...)
```

--------------------------------

### format

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Formats the installation plan for display. Currently, the ellipsis argument is not used.

```APIDOC
## Method `format()`

### Description
Formats the installation plan for display. The `...` argument is not used currently.

### Usage
```
pkg_installation_plan$format(...)
```

### Arguments

`...`
    
not used currently.

### Returns
A character vector, each element should be a line in the printout.
```

--------------------------------

### Install System Requirements

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Installs any necessary system requirements for the packages. This method does nothing if system requirements are disabled.

```r
pkg_installation_proposal$install_sysreqs()
```

--------------------------------

### new_pkg_installation_plan

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Creates a new pkg_installation_plan object. This object can then be used to download and install packages according to the plan.

```APIDOC
## Function: new_pkg_installation_plan

### Description
Creates a new `pkg_installation_plan` object. This object can be used to download and install packages according to the plan.

### Usage
```R
new_pkg_installation_plan(lockfile = "pkg.lock", config = list(), ...)
```

### Arguments

* `lockfile` (string) - Path to the lock file to use.
* `config` (list) - Configuration options. See 'Configuration'. If it does not include `library`, then `.libPaths()[1]` is added as `library`.
* `...` - Additional arguments, passed to `pkg_installation_plan$new()`.

### Value
`new_pkg_installation_plan()` returns a `pkg_installation_plan` object.
```

--------------------------------

### Error when asynchronously resolving dependencies for an installation plan

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

The `async_resolve()` method is implemented for installation plans but will always error, as the plan is already solved.

```r
pkg_installation_plan$async_resolve()
```

--------------------------------

### pkg_installation_plan$async_resolve

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Attempts to asynchronously resolve dependencies for the installation plan. This method is implemented but will error as plans are already solved.

```APIDOC
## Method: pkg_installation_plan$async_resolve

### Description
This function is implemented for installation plans, and will error because installation plans are already solved.

### Usage
```R
pkg_installation_plan$async_resolve()
```
```

--------------------------------

### Get solve policy for an installation plan

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Installation plans are already solved, so this method always returns `NA_character_`.

```r
pkg_installation_plan$get_solve_policy()
```

--------------------------------

### pkg_installation_proposal$draw

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Draws a graphical representation of the package installation proposal.

```APIDOC
## Method `pkg_installation_proposal$draw`

### Description
Draws a graphical representation of the package installation proposal.

### Method
`draw()`

### Request Example
```r
pdi <- new_pkg_installation_proposal(
  "pak",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$draw()
```
```

--------------------------------

### pkg_installation_plan$new

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Constructor for the pkg_installation_plan R6 class. It initializes the plan with a lockfile, configuration, and optional remote types.

```APIDOC
## Method: pkg_installation_plan$new

### Description
Create a new `pkg_installation_plan` object. Consider using `new_pkg_installation_plan()` instead of calling the constructor directly.
The returned object can be used to download and install packages, according to the plan.

### Usage
```R
pkg_installation_plan$new(
  lockfile = "pkg.lock",
  config = list(),
  remote_types = NULL
)
```

### Arguments

* `lockfile` (string) - Path to the lock file to use.
* `config` (list) - Configuration options. See 'Configuration'. It needs to include the package library to install to, in `library`.
* `remote_types` (any) - Custom remote ref types, this is for advanced use, and experimental currently.
```

--------------------------------

### Print Installation Proposal

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Prints a summary of the `pkg_installation_proposal` object to the console. It includes details on package references, solver status, download status, and next steps.

```r
pkg_installation_proposal$print(...)
```

--------------------------------

### Create a new pkg_installation_plan object

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Use this constructor to create a new pkg_installation_plan object. It takes a lockfile path and configuration options. The returned object can be used to download and install packages.

```r
new_pkg_installation_plan(lockfile = "pkg.lock", config = list(), ...)
```

--------------------------------

### pkg_installation_plan$solve

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Attempts to solve the dependencies for the installation plan. This method is implemented but will error as plans are already solved.

```APIDOC
## Method: pkg_installation_plan$solve

### Description
This function is implemented for installation plans, and will error because installation plans are already solved.

### Usage
```R
pkg_installation_plan$solve()
```
```

--------------------------------

### pkg_installation_plan$set_solve_policy

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Attempts to set the solve policy for the installation plan. This method is implemented but will error as plans are already solved.

```APIDOC
## Method: pkg_installation_plan$set_solve_policy

### Description
This function is implemented for installation plans, and will error because installation plans are already solved.

### Usage
```R
pkg_installation_plan$set_solve_policy()
```
```

--------------------------------

### Create and inspect a pkg_download_proposal

Source: https://r-lib.github.io/pkgdepends/reference/pkg_download_proposal.html

Initialize a package download proposal for a given repository and inspect its initial state. Use `$resolve()` to determine dependencies.

```r
pdl <- new_pkg_download_proposal("r-lib/pkgdepends")
pdl
```

--------------------------------

### Example: pkg_name Regex

Source: https://r-lib.github.io/pkgdepends/reference/pkg_rx.html

This regex defines a valid R package name, typically starting with a letter and followed by alphanumeric characters or dots.

```R
pkg_rx()$pkg_name
```

--------------------------------

### Handle Solution Errors

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Error if the dependency solver failed to find a consistent set of packages that can be installed together. This example demonstrates a scenario where packages conflict.

```r
pdi <- new_pkg_installation_proposal(
  c("r-lib/pak", "cran::pak"),
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi
# This fails:
# pdi$stop_for_solution_error()
```

--------------------------------

### pkg_installation_proposal$new

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Constructor for the pkg_installation_proposal class. Use `new_pkg_installation_proposal()` for a safer alternative.

```APIDOC
## Method: pkg_installation_proposal$new

### Description
Create a new `pkg_installation_proposal` object. Consider using `new_pkg_installation_proposal()` instead of calling the constructor directly. The returned object can be used to look up (recursive) dependencies of R packages from various sources, and then download and install the package files.

### Usage
```
pkg_installation_proposal$new(
  refs,
  config = list(),
  policy = c("lazy", "upgrade"),
  remote_types = NULL
)
```

### Arguments

*   `refs` (Package names or references) - Required. See 'Package references' for the syntax.
*   `config` (named list) - Required. Configuration options. See 'Configuration'. It needs to include the package library to install to, in `library`.
*   `policy` (character vector) - Optional. Solution policy. Defaults to `c("lazy", "upgrade")`. See 'The dependency solver'.
*   `remote_types` (NULL) - Optional. Custom remote ref types, this is for advanced use, and experimental currently.
```

--------------------------------

### Get status of installed packages

Source: https://r-lib.github.io/pkgdepends/reference/lib_status.html

Use `lib_status` to query data for all packages in a specified library path. If `packages` is not NULL, it filters the results to include only those packages.

```r
lib_status(library = .libPaths()[1], packages = NULL)
```

--------------------------------

### print()

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Prints a pkg_installation_proposal object to the screen. The printout includes the package refs, dependency solver policy, solution status, download status, and advice on next steps.

```APIDOC
## Method `print()`

### Description
Prints a `pkg_installation_proposal` object to the screen. The printout includes:
  * The package refs.
  * The policy of the dependency solver.
  * Whether the object has the solved dependencies.
  * Whether the solution had errors.
  * Whether the object has downloads.
  * Whether the downloads had errors.
  * Advice on which methods to call next.

See the example below.

### Usage
```r
pkg_installation_proposal$print(...)
```

### Arguments 

`...`
    
not used currently.

### Returns
The `pkg_installation_proposal` object itself, invisibly.

```

--------------------------------

### Initialize pkg_installation_proposal object

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Constructor for the pkg_installation_proposal class. Use this to initialize an object for looking up, downloading, and installing R packages and their dependencies. Ensure the 'config' list includes the 'library' path.

```r
pkg_installation_proposal$new(
  refs,
  config = list(),
  policy = c("lazy", "upgrade"),
  remote_types = NULL
)
```

--------------------------------

### Installed Package Reference

Source: https://r-lib.github.io/pkgdepends/reference/pkg_refs.html

Reference an installed package using the installed:: prefix, specifying the library path and package name. This is often used internally.

```R
installed::~/R/3.6/crayon
```

--------------------------------

### Create a new pkg_installation_proposal object

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Use this function to create a new pkg_installation_proposal object. It's recommended over directly calling the constructor to avoid build-time dependencies.

```r
new_pkg_installation_proposal(refs, config = list(), ...)
```

--------------------------------

### Install Missing System Packages

Source: https://r-lib.github.io/pkgdepends/reference/sysreqs_check_installed.html

Installs the system packages that are missing for the installed R packages. This function is the counterpart to `sysreqs_check_installed()` and helps resolve unmet system dependencies.

```r
sysreqs_fix_installed(packages = NULL, library = .libPaths()[1])
```

--------------------------------

### format()

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Format a pkg_installation_proposal object, typically for printing.

```APIDOC
## Method `format()`

### Description
Format a `pkg_installation_proposal` object, typically for printing.

### Usage
```r
pkg_installation_proposal$format(...)
```

### Arguments 

`...`
    
not used currently.

### Returns
A character vector, each element should be a line in the printout.

```

--------------------------------

### Initialize pkg_download_proposal with package references

Source: https://r-lib.github.io/pkgdepends/reference/pkg_download_proposal.html

Constructs a new `pkg_download_proposal` object. This object is used to look up dependencies and download package files. It accepts package references and optional configuration.

```R
pkg_download_proposal$new("r-lib/pkgdepends")
```

--------------------------------

### pkg_installation_proposal$solve

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_proposal.html

Solves the package installation proposal to determine the final installation plan.

```APIDOC
## Method `pkg_installation_proposal$solve`

### Description
Solves the package installation proposal to determine the final installation plan.

### Method
`solve()`

### Request Example
```r
pdi <- new_pkg_installation_proposal(
  "r-lib/pkgdepends",
  config = list(library = tempfile())
)
pdi$resolve()
pdi$solve()
pdi$get_solution()
```
```

--------------------------------

### Check Installed System Requirements

Source: https://r-lib.github.io/pkgdepends/reference/sysreqs_check_installed.html

Checks if the system requirements of all installed R packages (or a specified subset) are met. It returns a data frame indicating which system packages are installed and which R packages depend on them.

```APIDOC
## sysreqs_check_installed()

### Description
Checks if the system requirements of all packages (or a subset of packages) are installed.

### Usage
```R
sysreqs_check_installed(packages = NULL, library = .libPaths()[1])
```

### Arguments
* `packages` (character vector or NULL) - If not `NULL`, then only these packages are checked. If a package in `packages` is not installed, then pkgdepends throws a warning.
* `library` (character vector) - Library or libraries to check.

### Value
Data frame with a custom print and format method, and a `pkg_sysreqs_check_result` class. Its columns are:
* `system_package` (string) - name of the required system package.
* `installed` (logical) - whether the system package is correctly installed.
* `packages` (list column of character vectors) - The names of the installed R packages that need this system package.
* `pre_install` (list column of character vectors) - Commands to run before the installation of the system package.
* `post_install` (list column of character vectors) - Commands to run after the installation of the system package.

The data frame also has two attributes with additional data:
* `sysreqs_records` - the raw system requirements records.
* `system_packages` - the list of the installed system packages.

### Details
These functions use the `sysreqs_platform` configuration option, see `man_config_link("Configuration")`. Set this if pkgdepends does not detect your platform correctly.

### Examples
```R
# This only works on supported platforms
sysreqs_check_installed()
#> system package       installed required by                   
#> --------------       --        -----------
#> cmake                ✔         fs                            
#> git                  ✔         gitcreds                      
#> gsfonts              ✔         magick                        
#> libcurl4-openssl-dev ✔         curl                          
#> libfontconfig1-dev   ✔         systemfonts                   
#> libfreetype6-dev     ✔         ragg, systemfonts, textshaping
#> libfribidi-dev       ✔         textshaping                   
#> libharfbuzz-dev      ✔         textshaping                   
#> libicu-dev           ✔         stringi                       
#> libjpeg-dev          ✔         ragg                          
#> libmagick++-dev      ✔         magick                        
#> libnode-dev          ✔         V8                            
#> libpng-dev           ✔         ragg, svglite                 
#> libssl-dev           ✔         curl, openssl                 
#> libtiff-dev          ✔         ragg                          
#> libuv1-dev           ✔         fs                            
#> libwebp-dev          ✔         ragg                          
#> libxml2-dev          ✔         xml2                          
#> make                 ✔         fs, sass                      
#> pandoc               ✔         knitr, pkgdown, rmarkdown     
```
```

--------------------------------

### Install pkgdepends from CRAN

Source: https://r-lib.github.io/pkgdepends/index.html

Use this command to install the stable version of the pkgdepends package from CRAN.

```r
install.packages("pkgdepends")
```

--------------------------------

### Creating and Resolving a Package Download Proposal

Source: https://r-lib.github.io/pkgdepends/reference/pkg_download_proposal.html

Demonstrates how to initialize a package download proposal for a given repository, resolve its dependencies, and view the proposal's status.

```APIDOC
## Creating and Resolving a Package Download Proposal

### Description
This snippet shows how to create a new package download proposal for a specified package repository, resolve its dependencies, and then print the proposal object to see its current state.

### Method
Method calls on an object.

### Endpoint
N/A (R package methods)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```R
pdl <- new_pkg_download_proposal("r-lib/pkgdepends")
pdl
#> <pkg_download_proposal>
#> + refs:
#>   - r-lib/pkgdepends
#> (use `$resolve()` to resolve dependencies)

pdl$resolve()
pdl
#> <pkg_download_proposal>
#> + refs:
#>   - r-lib/pkgdepends
#> + has resolution (+13 dependencies)
#> (use `$download()` to download packages)
#> (use `$get_resolution()` to see resolution results)
```

### Response
#### Success Response (Object State)
- **pkg_download_proposal**: An object representing the package download proposal, showing its current state (e.g., refs, resolution status, download status).

#### Response Example
```
<pkg_download_proposal>
+ refs:
  - r-lib/pkgdepends
+ has resolution (+13 dependencies)
(use `$download()` to download packages)
(use `$get_resolution()` to see resolution results)
```
```

--------------------------------

### Update installation plan to current library state

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Updates the plan to reflect the current state of the library. If the library has not changed, it does nothing. If new packages are installed, it may reduce the need to download and install all packages from the plan.

```r
pkg_installation_plan$update()
```

--------------------------------

### pkg_installation_plan constructor

Source: https://r-lib.github.io/pkgdepends/reference/pkg_installation_plan.html

Directly construct a pkg_installation_plan object. This method is part of the R6 class definition and takes arguments for lockfile, configuration, and custom remote types.

```r
pkg_installation_plan$new(
  lockfile = "pkg.lock",
  config = list(),
  remote_types = NULL
)
```

--------------------------------

### Install pkgdepends Development Version

Source: https://r-lib.github.io/pkgdepends/index.html

Install the latest development version of pkgdepends using the pak package.

```r
pak::pak("r-lib/pkgdepends")
```
Tokens:
Raw