pms-utils

https://pms-utils.pages.dev/
Admin
pms-utils is a C++ library implementing the Gentoo Package Manager Specification, with a Python API,...
Tokens:54,593
Snippets:171
Trust Score:7.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### pms-utils Examples Overview

Source: https://pms-utils.pages.dev/_sources/index

This section provides links to examples demonstrating the usage of various pms-utils modules, including atom, depend, repo, and equery.

```Python
examples/atom
examples/depend
examples/repo
examples/equery
```

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

### pms-utils Examples

Source: https://pms-utils.pages.dev/vdb

The project includes examples demonstrating how to parse Atom expressions, iterate over DEPEND expressions, and interact with ebuild repositories, as well as implementing equery hasuse.

```Python
# Example usage (conceptual):
# Parsing an Atom expression:
# from pms.atom import Atom
# atom_expr = Atom('dev-libs/openssl[ssl,crt]')

# Iterating over a DEPEND expression:
# from pms.depend import Depend
# depend_expr = Depend('>=dev-libs/glib-2.0[X]')
# for dep in depend_expr.depend_list:
#     print(dep)

# Iterating over and accessing an ebuild repository:
# from pms.repo import Repo
# repo = Repo('/path/to/your/repo')
# for category in repo.categories():
#     for package in repo.packages(category):
#         print(f"{category}/{package}")

# Implementing equery hasuse (conceptual):
# def hasuse(package_name, use_flag):
#     # Logic to check use flag for a package
#     pass
```

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

### Entry Class Overview

Source: https://pms-utils.pages.dev/_sources/vdb/Entry

The Entry class represents a single VDB entry, providing metadata for each installed package. This includes details like USE flags, MD5SUM, and CFLAGS.

```Python
.. currentmodule:: pms_utils.vdb

This class represents a single VDB entry. There is one entry for each installed package. The VDB provides metadata about installed packages such as its USE flags, MD5SUM, CFLAGS, etc.

.. autoclass:: Entry

```

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

### pms-utils: S Module Contents

Source: https://pms-utils.pages.dev/genindex

Lists classes, properties, and attributes starting with 'S' in the pms-utils library, including setup, sign, size, Slot, slot, SLOT, SlotExpr, slotExpr, slotVariant, src, src_uri, SRC_URI, star, string, strip, strong, subslot, suffixes, and Sym.

```python
setup (pms_utils.ebuild.phases attribute)
sign (pms_utils.atom.Usedep property)
size (pms_utils.vdb.Entry property)
(pms_utils.vdb.Obj property)
(pms_utils.vdb.Sym property)
Slot (class in pms_utils.atom)
slot (pms_utils.atom.Slot property)
(pms_utils.atom.SlotExpr property)
SLOT (pms_utils.ebuild.Metadata property)
SlotExpr (class in pms_utils.atom)
slotExpr (pms_utils.atom.Atom property)
slotVariant (pms_utils.atom.SlotExpr property)
src (pms_utils.vdb.Sym property)
src_uri (class in pms_utils.ebuild)
SRC_URI (pms_utils.ebuild.Metadata property)
star (pms_utils.atom.SlotVariant attribute)
string (pms_utils.ebuild.properties_elem property)
(pms_utils.ebuild.restrict_elem property)
strip (pms_utils.ebuild.restrict_elem_type attribute)
strong (pms_utils.atom.Blocker attribute)
subslot (pms_utils.atom.Slot property)
suffixes (pms_utils.atom.Version property)
Sym (class in pms_utils.vdb)
```

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

### pms-utils Module Index

Source: https://pms-utils.pages.dev/genindex

Provides an index of the available modules within the pms-utils library, including atom, depend, ebuild, profile, repo, and vdb. Also lists examples of common use cases.

```APIDOC
Modules:
  * atom
  * depend
  * ebuild
  * profile
  * repo
  * vdb

Examples:
  * Parsing an Atom expression
  * Iterating over a DEPEND expression
  * Iterating over and accessing an ebuild repository
  * Implementing equery hasuse
```

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

### pms-utils Entry Class Properties

Source: https://pms-utils.pages.dev/vdb/Entry

This section details the properties of the Entry class, which represents an installed package's metadata. Each property provides specific information like dependencies, contents, USE flags, and repository details.

```APIDOC
pms_utils.vdb.Entry

This class represents a single VDB entry. There is one entry for each installed package. The VDB provides metadata about installed packages such as its USE flags, MD5SUM, CFLAGS, etc.

Properties:
  bdepend: pms_utils.depend.DependExpr
    Represents the build dependencies of the package.
  contents: list[pms_utils.vdb.Content]
    A list of contents associated with the package.
  depend: pms_utils.depend.DependExpr
    Represents the runtime dependencies of the package.
  iuse: pms_utils.ebuild.iuse
    Information about the package's IUSE flags.
  keywords: pms_utils.ebuild.keywords
    Information about the package's keywords.
  package: pms_utils.vdb.Package
    Details about the package itself.
  path: pathlib.Path
    The file system path to the package.
  rdepend: pms_utils.depend.DependExpr
    Represents the reverse dependencies of the package.
  repository: str
    The name of the repository the package belongs to.
  size: int
    The size of the installed package.
  use: list[pms_utils.atom.Useflag]
    A list of USE flags applied to the package.
```

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

### Accessing Ebuild Repositories

Source: https://pms-utils.pages.dev/profile

Illustrates how to iterate over and access information within an ebuild repository, a key component of Gentoo-like package management.

```Python
# Example usage (conceptual)
# from pms.repo import Repo
# repo_path = "/path/to/your/repo"
# repository = Repo(repo_path)
# for category in repository.categories():
#     for package in repository.packages(category):
#         print(f"{category}/{package}")
```

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

### Portage VDB Module Overview

Source: https://pms-utils.pages.dev/_sources/vdb

This section introduces the pms_utils.vdb module, explaining its purpose of providing access to the Portage VDB. It highlights the main class, Vdb, and lists the submodules available for detailed documentation.

```python
.. module:: pms_utils.vdb

| This module provides access to the Portage VDB (virtual data base) which stores information about the systems installed packages.
| The primary class is :py:class:`Vdb`.

.. toctree::
    :maxdepth: 1

    vdb/Obj
    vdb/Dir
    vdb/Sym
    vdb/Content
    vdb/Package
    vdb/Entry
    vdb/Vdb
    vdb/Category
```

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

### pms-utils: W Module Contents

Source: https://pms-utils.pages.dev/genindex

Lists classes, properties, and attributes starting with 'W' in the pms-utils library, including weak and word.

```python
weak (pms_utils.atom.Blocker attribute)
word (pms_utils.atom.VersionSuffix property)
```

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

### pms-utils: T Module Contents

Source: https://pms-utils.pages.dev/genindex

Lists classes, properties, and attributes starting with 'T' in the pms-utils library, including td, test, test_network, and type.

```python
td (pms_utils.atom.VersionSpecifier attribute)
test (pms_utils.ebuild.phases attribute)
(pms_utils.ebuild.restrict_elem_type attribute)
test_network (pms_utils.ebuild.properties_elem_type attribute)
type (pms_utils.ebuild.properties_elem property)
(pms_utils.ebuild.restrict_elem property)
```

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

### Portage VDB Access with pms-utils

Source: https://pms-utils.pages.dev/vdb

This module provides access to the Portage VDB (virtual data base) which stores information about the systems installed packages. The primary class is `Vdb`.

```Python
from pms.vdb import Vdb

# Example usage (conceptual):
# vdb = Vdb()
# installed_packages = vdb.get_installed_packages()
# print(installed_packages)
```

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

### Directly accessing packages in an ebuild repository

Source: https://pms-utils.pages.dev/examples/repo

Shows how to directly access a specific package within an ebuild repository using dictionary-like indexing. This method allows for quick retrieval of package information by its category and name, with optional version indexing.

```Python
>>> repo = pms_utils.repo.Repository("/var/db/repos/gentoo")
>>> portage_pkg = repo["sys-apps"]["portage"] # you can also further index by version
```

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

### Ebuild Class Documentation

Source: https://pms-utils.pages.dev/_sources/repo/Ebuild

Provides detailed documentation for the Ebuild class, including its purpose and usage within the pms_utils.repo module. This class is designed to represent a single ebuild file.

```Python
class Ebuild:
    """Represents a single ebuild file within a repo package directory."""
    pass
```

```APIDOC
Ebuild:
  __init__(self, path: str)
    Initializes an Ebuild object.
    Parameters:
      path: The file path to the ebuild file.

  get_variables(self) -> dict
    Retrieves all variables defined in the ebuild file.
    Returns: A dictionary of ebuild variables.

  get_dependencies(self) -> list
    Retrieves the dependencies of the ebuild.
    Returns: A list of dependency strings.

  get_description(self) -> str
    Retrieves the description of the ebuild.
    Returns: The ebuild description string.
```

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

### pms-utils: V Module Contents

Source: https://pms-utils.pages.dev/genindex

Lists classes, properties, and attributes starting with 'V' in the pms-utils library, including Vdb, Version, version, VersionNumber, VersionRevision, VersionSuffix, and verspec.

```python
Vdb (class in pms_utils.vdb)
Version (class in pms_utils.atom)
version (pms_utils.atom.Atom property)
(pms_utils.repo.Ebuild property)
(pms_utils.vdb.Package property)
VersionNumber (class in pms_utils.atom)
VersionRevision (class in pms_utils.atom)
VersionSuffix (class in pms_utils.atom)
verspec (pms_utils.atom.Atom property)
```

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

### pms-utils homepage Class Documentation

Source: https://pms-utils.pages.dev/ebuild/homepage

Provides detailed documentation for the `homepage` class in the `pms-utils` library. This class represents a HOMEPAGE dependency expression as defined in PMS 8.2. It includes information on the constructor, iteration, and properties.

```APIDOC
homepage
This class represents a _HOMEPAGE_ dependency expression as per PMS 8.2.

__init__(_self_, _expr :str_)
    Constructs a new homepage object from the input expression.

    Raises:
        ValueError: The expression is invalid.

__iter__(_self_) → collections.abc.Iterator[pms_utils.ebuild.URI|pms_utils.ebuild.homepage]

conditional _property_ : pms_utils.depend.UseConditional|pms_utils.depend.GroupHeaderOp|None_
    (self) -> pms_utils.depend.UseConditional | pms_utils.depend.GroupHeaderOp | None

nodes _property_ : list[pms_utils.ebuild.URI|pms_utils.ebuild.homepage]_
    (self) -> list[pms_utils.ebuild.URI | pms_utils.ebuild.homepage]
```

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

### pms-utils Modules Overview

Source: https://pms-utils.pages.dev/vdb

The pms-utils project is organized into several modules, including atom, depend, ebuild, profile, and repo. The repo module further contains sub-modules like Obj, Dir, Sym, Content, Package, Entry, Vdb, and Category.

```Python
# Importing from modules (conceptual):
# import pms.atom
# import pms.depend
# import pms.ebuild
# import pms.profile
# import pms.repo.Obj
# import pms.repo.Dir
# import pms.repo.Sym
# import pms.repo.Content
# import pms.repo.Package
# import pms.repo.Entry
# import pms.repo.Vdb
# import pms.repo.Category
```

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

### Ebuild Module Overview

Source: https://pms-utils.pages.dev/ebuild

This module provides access to various ebuild variables as defined in PMS 7. The core class is `Metadata`, which is accessed via an instance of `pms_utils.repo.Ebuild`. It covers elements like URI, license, keywords, properties, and phases.

```python
import pms_utils.repo

# Example of accessing ebuild metadata (conceptual)
repo = pms_utils.repo.Ebuild("path/to/your/repo")
metadata = repo.get_metadata()

print(metadata.uri)
print(metadata.license)
print(metadata.keywords)
print(metadata.properties)
print(metadata.phases)
```

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

### pms-utils: U Module Contents

Source: https://pms-utils.pages.dev/genindex

Lists classes, properties, and attributes starting with 'U' in the pms-utils library, including UNKNOWN, unpack, URI, uri, uri_elem, use, USE, use_force, use_mask, use_stable_force, use_stable_mask, UseConditional, Usedep, Usedeps, usedeps, Useflag, useflag, and userpriv.

```python
UNKNOWN (pms_utils.ebuild.properties_elem_type attribute)
(pms_utils.ebuild.restrict_elem_type attribute)
unpack (pms_utils.ebuild.phases attribute)
URI (class in pms_utils.ebuild)
uri (pms_utils.ebuild.uri_elem property)
uri_elem (class in pms_utils.ebuild)
use (pms_utils.profile.Filters property)
USE (pms_utils.profile.Profile property)
use (pms_utils.vdb.Entry property)
USE_EXPAND (pms_utils.profile.Profile property)
USE_EXPAND_HIDDEN (pms_utils.profile.Profile property)
USE_EXPAND_IMPLICIT (pms_utils.profile.Profile property)
USE_EXPAND_UNPREFIXED (pms_utils.profile.Profile property)
use_force (pms_utils.profile.Filters property)
(pms_utils.profile.Profile property)
use_mask (pms_utils.profile.Filters property)
(pms_utils.profile.Profile property)
use_stable_force (pms_utils.profile.Filters property)
(pms_utils.profile.Profile property)
use_stable_mask (pms_utils.profile.Filters property)
(pms_utils.profile.Profile property)
UseConditional (class in pms_utils.depend)
Usedep (class in pms_utils.atom)
Usedeps (class in pms_utils.atom)
usedeps (pms_utils.atom.Atom property)
Useflag (class in pms_utils.atom)
useflag (pms_utils.atom.Usedep property)
(pms_utils.depend.UseConditional property)
(pms_utils.ebuild.iuse_elem property)
userpriv (pms_utils.ebuild.restrict_elem_type attribute)
```

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

### pms-utils __iter__ Methods

Source: https://pms-utils.pages.dev/genindex

Lists the __iter__ methods available in various pms-utils classes, such as pms_utils.atom.Usedeps, pms_utils.depend.DependExpr, pms_utils.ebuild.defined_phases, and several others related to ebuild and repository handling.

```APIDOC
__iter__() (pms_utils.atom.Usedeps method)
__iter__() (pms_utils.atom.VersionNumber method)
__iter__() (pms_utils.depend.DependExpr method)
__iter__() (pms_utils.ebuild.defined_phases method)
__iter__() (pms_utils.ebuild.homepage method)
__iter__() (pms_utils.ebuild.inherited method)
__iter__() (pms_utils.ebuild.iuse method)
__iter__() (pms_utils.ebuild.keywords method)
__iter__() (pms_utils.ebuild.license method)
__iter__() (pms_utils.ebuild.properties method)
__iter__() (pms_utils.ebuild.required_use method)
__iter__() (pms_utils.ebuild.restrict method)
__iter__() (pms_utils.ebuild.src_uri method)
__iter__() (pms_utils.repo.Category method)
__iter__() (pms_utils.repo.Package method)
__iter__() (pms_utils.repo.Repository method)
__iter__() (pms_utils.vdb.Category method)
__iter__() (pms_utils.vdb.Dir method)
__iter__() (pms_utils.vdb.Vdb method)
```

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

### Find Packages by Useflag using pms-utils

Source: https://pms-utils.pages.dev/_sources/examples/equery

This Python function, 'hasuse', takes a useflag as input and returns a list of packages that utilize this useflag. It iterates through a Gentoo repository, checking each package's ebuild metadata for the specified useflag. Dependencies include the pms-utils library and access to the Gentoo repository path.

```Python
>>> def hasuse(useflag: pms_utils.atom.Useflag) -> list[pms_utils.repo.Package]:
...     ret = []
...     repo = pms_utils.repo.Repository("/var/db/repos/gentoo")
...     def check_package(package: pms_utils.repo.Package) -> bool:
...         for ebuild in package:
...             for iuse_elem in ebuild.metadata.IUSE:
...                 if iuse_elem.useflag == useflag:
...                     return True
...         return False
...     for category in repo:
...         for package in category:
...             if check_package(package):
...                 ret.append(package)
...     return ret
```

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

### Iterating through an ebuild repository

Source: https://pms-utils.pages.dev/examples/repo

Demonstrates how to iterate through the hierarchical structure of an ebuild repository, including categories, packages, and individual ebuilds. This is useful for discovering and processing package information.

```Python
>>> repo = pms_utils.repo.Repository("/var/db/repos/gentoo")
>>> for category in repo: # sys-apps
...     for package in category: # sys-apps/portage
...         for ebuild in package: # sys-apps/portage-3.0.65
...             pass
```

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

### Iterate Ebuild Repository - Python

Source: https://pms-utils.pages.dev/_sources/examples/repo

Demonstrates iterating through a repository object to access categories, packages, and ebuilds. This is useful for discovering available packages within a repository structure.

```Python
import pms_utils

repo = pms_utils.repo.Repository("/var/db/repos/gentoo")
for category in repo: # sys-apps
    for package in category: # sys-apps/portage
        for ebuild in package: # sys-apps/portage-3.0.65
            pass
```

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

### Repository Class Documentation

Source: https://pms-utils.pages.dev/_sources/repo/Repository

Provides documentation for the Repository class, which represents an ebuild repository based on PMS 4 specifications. It details the class and its methods.

```Python
.. currentmodule:: pms_utils.repo

This class represents an ebuild repository as per `PMS 4 <https://projects.gentoo.org/pms/8/pms.html#x1-280004>`_.

.. autoclass:: Repository
```

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

### Keyword Class Documentation

Source: https://pms-utils.pages.dev/_sources/ebuild/keyword

Provides detailed documentation for the Keyword class, including its inheritance and adherence to PMS specifications. This is auto-generated documentation.

```APIDOC
.. currentmodule:: pms_utils.ebuild

This class represents a keyword as per `PMS 3.1.7 <https://projects.gentoo.org/pms/8/pms.html#x1-230003.1.7>`_.

.. autoclass:: keyword
```

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

### Profile Module Overview

Source: https://pms-utils.pages.dev/_sources/profile

This section provides an overview of the profile module, detailing its purpose in handling PMS and Portage profiles. It references the PMS specification and highlights the key classes involved.

```Python
.. module:: pms_utils.profile

| This module provides facilities for introspecting profiles as per `PMS 5 <https://projects.gentoo.org/pms/8/pms.html#x1-410005>`_ and as extended by Portage.
| The PMS profile is implemented in :py:class:`Profile` and the Portage profile is a child class of this in :py:class:`PortageProfile`.

.. toctree::
    :maxdepth: 1

    profile/expand_package_expr
    profile/Filters
    profile/Profile
    profile/PortageProfile
```

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

### Vdb Class Documentation

Source: https://pms-utils.pages.dev/vdb/Vdb

Documentation for the Vdb class, its constructor, iteration method, and path property.

```APIDOC
Vdb:
  Represents the VDB itself.

  __init__(_self_, _arg: str | os.PathLike_, _/_):
    Initializes the Vdb object.
    Parameters:
      _arg: A string or os.PathLike object representing the VDB path.

  __iter__(_self_) → collections.abc.Iterator[pms_utils.vdb.Category]:
    Iterates over the categories within the VDB.
    Returns: An iterator yielding Category objects.

  path _: pathlib.Path_:
    A property that returns the path to the VDB.
    Returns: A pathlib.Path object representing the VDB path.
```

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

### PortageProfile Class Documentation

Source: https://pms-utils.pages.dev/_sources/profile/PortageProfile

This section provides documentation for the PortageProfile class, detailing its representation of a user profile as implemented by Portage. It highlights differences from PMS profiles, such as directory layout and the allowance of wildcard expressions, referencing 'man portage.5' for further details.

```APIDOC
.. currentmodule:: pms_utils.profile

| This class represents a user profile as implemented by portage. It differs from a PMS profile in directory layout and in allowing wildcard expressions.
| See `man portage.5`.

.. autoclass:: PortageProfile
```

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

### Access Ebuild Package by Index - Python

Source: https://pms-utils.pages.dev/_sources/examples/repo

Shows how to directly access a specific package within an ebuild repository using category and package names as keys. This method allows for quick retrieval of package information.

```Python
import pms_utils

repo = pms_utils.repo.Repository("/var/db/repos/gentoo")
portage_pkg = repo["sys-apps"]["portage"] # you can also further index by version
```

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

### Vdb Class Overview

Source: https://pms-utils.pages.dev/_sources/vdb/Vdb

Provides an overview of the Vdb class, its module, and its purpose as the VDB itself.

```Python
.. currentmodule:: pms_utils.vdb

This class represents the Vdb itself.

.. autoclass:: Vdb
```

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

### Implementing equery hasuse

Source: https://pms-utils.pages.dev/profile

Details on how to implement the functionality equivalent to `equery hasuse`, which is used to query USE flags for packages.

```Python
# Example usage (conceptual)
# from pms.ebuild import Ebuild
# ebuild_path = "/path/to/package.ebuild"
# ebuild_file = Ebuild(ebuild_path)
# use_flags = ebuild_file.use_flags()
# print(use_flags)
```

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

### Package Class Methods and Properties

Source: https://pms-utils.pages.dev/repo/Package

Details the Package class from the pms_utils.repo module, including its methods for iteration and item retrieval, and its properties for package name and path.

```APIDOC
pms_utils.repo.Package
  Represents a repo package as per PMS 4.3.

  Methods:
    __iter__(_self_) -> collections.abc.Iterator[pms_utils.repo.Ebuild]
      Allows iteration over the package, yielding Ebuild objects.

    __getitem__(_self_, _arg: pms_utils.atom.Version_, _/_) -> pms_utils.repo.Ebuild | None
      Retrieves an Ebuild object using a Version object as the key.

    __getitem__(_self_, _arg: str, _/_) -> pms_utils.repo.Ebuild | None
      Retrieves an Ebuild object using a string as the key.

  Properties:
    name: pms_utils.atom.Name
      The name of the package.
      (self) -> pms_utils.atom.Name

    path: pathlib.Path
      The file system path to the package.
      (self) -> pathlib.Path
```

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

### pms-utils Modules Overview

Source: https://pms-utils.pages.dev/_sources/index

This section lists the primary modules available in the pms-utils Python library, each corresponding to a specific aspect of the Gentoo Package Manager Specification.

```Python
atom
depend
ebuild
profile
repo
vdb
```

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

### License Class Initialization and Properties (Python)

Source: https://pms-utils.pages.dev/ebuild/license

This snippet details the License class from the pms_utils.ebuild module, used to represent the LICENSE ebuild variable. It covers the constructor, which takes a string expression and raises ValueError for invalid input, and its properties: 'conditional' for use conditions and 'nodes' for a list of license elements.

```APIDOC
class pms_utils.ebuild.license(_self_, _expr: str)
    Constructs a new license object from the input expression.

    Raises:
        ValueError: The expression is invalid.

    __iter__() -> collections.abc.Iterator[pms_utils.ebuild.license_elem|pms_utils.ebuild.license]
        Iterates over the license elements.

    property conditional: pms_utils.depend.UseConditional|pms_utils.depend.GroupHeaderOp|None
        Represents the conditional part of the license expression.

    property nodes: list[pms_utils.ebuild.license_elem|pms_utils.ebuild.license]
        A list of license elements within the expression.
```

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

### pms-utils Repository Module Overview

Source: https://pms-utils.pages.dev/_sources/repo

This section provides an overview of the repository module in pms-utils, which implements a PMS repository based on PMS 4 specifications. It outlines the primary class and links to further documentation for specific components.

```reStructuredText
.. module:: pms_utils.repo

| This module implements a PMS repository as per `PMS 4 <https://projects.gentoo.org/pms/8/pms.html#x1-280004>`_.
| The primary class is :py:class:`Repository`.

.. toctree::
    :maxdepth: 1

    repo/parse_metadata
    repo/Ebuild
    repo/Package
    repo/Category
    repo/Repository

```

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

### properties_elem Class Documentation

Source: https://pms-utils.pages.dev/_sources/ebuild/properties_elem

Documentation for the properties_elem class, which represents ebuild properties. It integrates PMS token types with raw string values for flexibility.

```Python
.. currentmodule:: pms_utils.ebuild

| This class represents a single ebuild property as per `PMS 7.3.6 <https://projects.gentoo.org/pms/8/pms.html#x1-680007.3.6>`_.
| It combines an enum of type :py:enum:`restrict_elem_type` to discern between the tokens defined by PMS, and the raw string representation, for use when the token not defined in PMS. The string representation is initialized for known tokens aswell.

.. autoclass:: properties_elem
```

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

### Python: Implement equery hasuse with pms-utils

Source: https://pms-utils.pages.dev/examples/equery

This Python code snippet demonstrates how to find all packages that contain a given use flag using the pms-utils library. It defines a function `defhasuse` that takes a use flag as input and returns a list of packages associated with that flag. The function iterates through a specified repository, checks each package's metadata for the use flag, and collects matching packages.

```Python
>>> defhasuse(useflag: pms_utils.atom.Useflag) -> list[pms_utils.repo.Package]:
...     ret = []
...     repo = pms_utils.repo.Repository("/var/db/repos/gentoo")
...     defcheck_package(package: pms_utils.repo.Package) -> bool:
...         for ebuild in package:
...             for iuse_elem in ebuild.metadata.IUSE:
...                 if iuse_elem.useflag == useflag:
...                     return True
...         return False
...     for category in repo:
...         for package in category:
...             if check_package(package):
...                 ret.append(package)
...     return ret
```

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

### Ebuild Module Overview

Source: https://pms-utils.pages.dev/_sources/ebuild

This module provides access to various ebuild variables as defined by PMS 7. The primary class is Metadata, which is accessed through an instance of pms_utils.repo.Ebuild.

```python
import pms_utils.repo

# Accessing Metadata through an Ebuild instance
# ebuild_instance = pms_utils.repo.Ebuild()
# metadata = ebuild_instance.Metadata()
```

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

### uri_elem Class Documentation

Source: https://pms-utils.pages.dev/_sources/ebuild/uri_elem

Provides documentation for the uri_elem class, which represents a single element of the src_uri list. It details the class structure and its usage within the pms_utils.ebuild module.

```python
.. currentmodule:: pms_utils.ebuild

This class represents a single element of the :py:class:`src_uri` list.

.. autoclass:: uri_elem
```

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

### pms_utils.ebuild.restrict Class Documentation

Source: https://pms-utils.pages.dev/ebuild/restrict

Documentation for the restrict class, which represents the _RESTRICT ebuild variable. It covers the constructor, iteration, and properties.

```APIDOC
class pms_utils.ebuild.restrict(_self_, _expr: str_)
    Constructs a new restrict object from the input expression.

    Raises:
        ValueError: The expression is invalid.

    __iter__(_self_) → collections.abc.Iterator[pms_utils.ebuild.restrict_elem|pms_utils.ebuild.restrict]

    property conditional: pms_utils.depend.UseConditional|pms_utils.depend.GroupHeaderOp|None
        (self) -> pms_utils.depend.UseConditional | pms_utils.depend.GroupHeaderOp | None

    property nodes: list[pms_utils.ebuild.restrict_elem|pms_utils.ebuild.restrict]
        (self) -> list[pms_utils.ebuild.restrict_elem | pms_utils.ebuild.restrict]
```

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

### Package Class Documentation

Source: https://pms-utils.pages.dev/_sources/vdb/Package

Provides documentation for the Package class, which represents the second path component of a VDB entry. This component typically includes the package name and version of an Atom.

```python
.. currentmodule:: pms_utils.vdb

This class represents the second path component of a VDB entry (category/package-version), which is the name and version parts of an Atom.

.. autoclass:: Package
```

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

### pms-utils __getitem__ Methods

Source: https://pms-utils.pages.dev/genindex

Documents the __getitem__ method across different classes in pms-utils, including pms_utils.repo.Category, pms_utils.repo.Package, and pms_utils.repo.Repository.

```APIDOC
__getitem__() (pms_utils.repo.Category method)
__getitem__() (pms_utils.repo.Package method)
__getitem__() (pms_utils.repo.Repository method)
```

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

### Profile Class Properties

Source: https://pms-utils.pages.dev/profile/Profile

This section details the properties of the Profile class, which represents a Gentoo profile. It covers attributes like ARCH, EAPI, use flags, configuration protection, and package information.

```APIDOC
class pms_utils.profile.Profile(_self_, _arg: str | os.PathLike_, _/_) 

  Represents a profile as per PMS 5.

  Properties:
    ARCH: str
      Returns the architecture of the profile.
    CONFIG_PROTECT: set[pathlib.Path]
      Returns a set of paths protected from configuration overwrites.
    CONFIG_PROTECT_MASK: set[pathlib.Path]
      Returns a set of paths masked from configuration protection.
    EAPI: str
      Returns the EAPI (Ebuild API) version used by the profile.
    ENV_UNSET: set[str]
      Returns a set of environment variables that are unset in this profile.
    IUSE_IMPLICIT: set[pms_utils.atom.Useflag]
      Returns a set of implicitly enabled USE flags.
    USE: set[pms_utils.atom.Useflag]
      Returns a set of explicitly defined USE flags.
    USE_EXPAND: set[str]
      Returns a set of USE_EXPAND variables.
    USE_EXPAND_HIDDEN: set[str]
      Returns a set of hidden USE_EXPAND variables.
    USE_EXPAND_IMPLICIT: set[str]
      Returns a set of implicitly expanded USE flags.
    USE_EXPAND_UNPREFIXED: set[str]
      Returns a set of un-prefixed USE_EXPAND variables.
    deprecated: bool
      Indicates if the profile is deprecated.
    filters: dict[str, pms_utils.profile.Filters]
      Returns a dictionary of filters applied to the profile.
    make_defaults: dict[str, str]
      Returns a dictionary of make.defaults values.
    make_defaults_unevaluated: list[tuple[str, str]]
      Returns a list of unevaluated make.defaults entries.
    name: str
      Returns the name of the profile.
    packages: set[pms_utils.atom.Atom]
      Returns a set of Atom objects representing packages in the profile.
    parents: list[pms_utils.profile.Profile]
      Returns a list of parent profiles.
    path: pathlib.Path
      Returns the file system path to the profile.
    use_force: set[str]
      Returns a set of USE flags that are forced.
    use_mask: set[str]
      Returns a set of USE flags that are masked.
    use_stable_force: set[str]
      Returns a set of stable USE flags that are forced.
    use_stable_mask: set[str]
      Returns a set of stable USE flags that are masked.
```

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

### VersionSuffix Class Documentation

Source: https://pms-utils.pages.dev/_sources/atom/VersionSuffix

Provides documentation for the VersionSuffix class, detailing its representation of version suffixes and numbers based on PMS 3.2 specifications. This includes its module and inheritance information.

```python
.. currentmodule:: pms_utils.atom

This class represents a version suffix + number as per `PMS 3.2 <https://projects.gentoo.org/pms/8/pms.html#x1-250003.2>`_.

.. autoclass:: VersionSuffix
```

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

### Properties Ebuild Class Documentation

Source: https://pms-utils.pages.dev/_sources/ebuild/properties

This section details the Properties class, which models the PROPERTIES ebuild variable according to PMS 7.3 specifications. It includes information on its usage and integration within the pms-utils library.

```python
.. currentmodule:: pms_utils.ebuild

This class represents the *PROPERTIES* ebuild variable as per `PMS 7.3 <https://projects.gentoo.org/pms/8/pms.html#x1-620007.3>`_.

.. autoclass:: properties
```

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

### UseConditional Class Documentation

Source: https://pms-utils.pages.dev/_sources/depend/UseConditional

Provides detailed documentation for the UseConditional class, including its purpose and reference to the PMS specification.

```python
.. currentmodule:: pms_utils.depend

This class represents an *use-conditional* dependency group as per `PMS 8.2 <https://projects.gentoo.org/pms/8/pms.html#x1-730008.2>`_.

.. autoclass:: UseConditional
```

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

### pms-utils Attributes and Classes (F-H)

Source: https://pms-utils.pages.dev/genindex

Details attributes like 'fetch', 'filename', 'filters', 'ge', 'gt', 'homepage', 'HOMEPAGE', and classes like 'Filters' within the pms-utils library.

```APIDOC
fetch (pms_utils.ebuild.restrict_elem_type attribute)
filename (pms_utils.ebuild.uri_elem property)
Filters (class in pms_utils.profile)
filters (pms_utils.profile.Profile property)
ge (pms_utils.atom.VersionSpecifier attribute)
gt (pms_utils.atom.VersionSpecifier attribute)
homepage (class in pms_utils.ebuild)
HOMEPAGE (pms_utils.ebuild.Metadata property)
```

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

### pms_utils.ebuild.Metadata Class Properties

Source: https://pms-utils.pages.dev/ebuild/Metadata

Provides access to ebuild metadata values. Includes properties for accessing dependencies, descriptions, EAPI, homepage, inherited elements, IUSE, keywords, license, properties, required use, restrict, slot, and source URI.

```APIDOC
class pms_utils.ebuild.Metadata:

  BDEPEND: pms_utils.depend.DependExpr
    (self) -> pms_utils.depend.DependExpr

  DEFINED_PHASES: pms_utils.ebuild.defined_phases
    (self) -> pms_utils.ebuild.defined_phases

  DEPEND: pms_utils.depend.DependExpr
    (self) -> pms_utils.depend.DependExpr

  DESCRIPTION: str
    (self) -> str

  EAPI: pms_utils.ebuild.eapi
    (self) -> pms_utils.ebuild.eapi

  HOMEPAGE: pms_utils.ebuild.homepage
    (self) -> pms_utils.ebuild.homepage

  IDEPEND: pms_utils.depend.DependExpr
    (self) -> pms_utils.depend.DependExpr

  INHERITED: pms_utils.ebuild.inherited
    (self) -> pms_utils.ebuild.inherited

  IUSE: pms_utils.ebuild.iuse
    (self) -> pms_utils.ebuild.iuse

  KEYWORDS: pms_utils.ebuild.keywords
    (self) -> pms_utils.ebuild.keywords

  LICENSE: pms_utils.ebuild.license
    (self) -> pms_utils.ebuild.license

  PDEPEND: pms_utils.depend.DependExpr
    (self) -> pms_utils.depend.DependExpr

  PROPERTIES: pms_utils.ebuild.properties
    (self) -> pms_utils.ebuild.properties

  RDEPEND: pms_utils.depend.DependExpr
    (self) -> pms_utils.depend.DependExpr

  REQUIRED_USE: pms_utils.ebuild.required_use
    (self) -> pms_utils.ebuild.required_use

  RESTRICT: pms_utils.ebuild.restrict
    (self) -> pms_utils.ebuild.restrict

  SLOT: pms_utils.atom.Slot
    (self) -> pms_utils.atom.Slot

  SRC_URI: pms_utils.ebuild.src_uri
    (self) -> pms_utils.ebuild.src_uri
```
Tokens:
Raw