py-rattler 0.22.0__cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

py_rattler-0.22.0.dist-info/METADATA

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: py-rattler
+Version: 0.22.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Typing :: Typed
+Summary: A blazing fast library to work with the conda ecosystem
+Author-email: Bas Zalmstra <zalmstra.bas@gmail.com>, Tarun Pratap Singh <pratapsinghtarun9@gmail.com>
+License-Expression: BSD-3-Clause
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/conda/rattler
+Project-URL: Documentation, https://conda.github.io/rattler/py-rattler/
+Project-URL: Repository, https://github.com/conda/rattler
+Project-URL: Issues, https://github.com/conda/rattler/labels/python-bindings
+
+<a href="https://prefix.dev/tools/rattler/">
+  <img src="https://github.com/user-attachments/assets/73dee0d8-b372-4462-bce1-f004c5f907b5" alt="banner">
+</a>
+
+# Rattler: Rust crates for fast handling of conda packages
+
+![License][license-badge]
+[![Build Status][build-badge]][build]
+[![Project Chat][chat-badge]][chat-url]
+[![Pixi Badge][pixi-badge]][pixi-url]
+[![docs main][docs-main-badge]][docs-main]
+[![python docs main][py-docs-main-badge]][py-docs-main]
+
+[license-badge]: https://img.shields.io/badge/license-BSD--3--Clause-blue?style=flat-square
+[build-badge]: https://img.shields.io/github/actions/workflow/status/conda/rattler/rust-compile.yml?style=flat-square&branch=main
+[build]: https://github.com/conda/rattler/actions
+[chat-badge]: https://img.shields.io/discord/1082332781146800168.svg?label=&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2&style=flat-square
+[chat-url]: https://discord.gg/kKV8ZxyzY4
+[docs-main-badge]: https://img.shields.io/badge/rust_docs-main-yellow.svg?style=flat-square
+[docs-main]: https://conda.github.io/rattler
+[py-docs-main-badge]: https://img.shields.io/badge/python_docs-main-yellow.svg?style=flat-square
+[py-docs-main]: https://conda.github.io/rattler/py-rattler
+[pixi-badge]:https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json&style=flat-square
+[pixi-url]: https://pixi.sh
+
+Rattler is a library that provides common functionality used within the conda ecosystem ([what is conda & conda-forge?](#what-is-conda--conda-forge)).
+The goal of the library is to enable programs and other libraries to easily interact with the conda ecosystem without being dependent on Python.
+Its primary use case is as a library that you can use to provide conda related workflows in your own tools.
+
+Rattler is written in Rust and tries to provide a clean API to its functionalities (see: [Components](#components)).
+With the primary goal in mind we aim to provide bindings to different languages to make it easy to integrate Rattler in non-rust projects.
+
+Rattler is actively used by [pixi](https://github.com/prefix-dev/pixi), [rattler-build](https://github.com/prefix-dev/rattler-build), and the https://prefix.dev backend.
+
+## Showcase
+
+This repository also contains a binary (use `cargo run` to try) that shows some of the capabilities of the library.
+This is an example of installing an environment containing `cowpy` and all its dependencies _from scratch_ (including Python!):
+
+![Installing an environment](https://github.com/conda/rattler/assets/4995967/c7946f6e-28a9-41ef-8836-ef4b4c94d273)
+
+## Python and Javascript bindings
+
+You can invoke `rattler` from Python or Javascript via our powerful bindings to solve, install and run commands in conda environments. Rattler offers you the fastest and cleanest Python bindings to the conda ecosystem.
+
+### Python
+
+To install the Python bindings, you can use pip or conda:
+
+```bash
+pip install py-rattler
+# or
+conda install -c conda-forge py-rattler
+```
+
+You can find the extensive documentation for the Python bindings [here](https://conda.github.io/rattler/py-rattler/).
+
+<details>
+  <summary>Example usage of rattler from Python</summary>
+The Python bindings to rattler are designed to be used with `asyncio`. You can access the raw power of the rattler library to solve environments, install packages, and run commands in the installed environments.
+
+```python
+import asyncio
+import tempfile
+
+from rattler import solve, install, VirtualPackage
+
+async def main() -> None:
+    # Start by solving the environment.
+    #
+    # Solving is the process of going from specifications of package and their
+    # version requirements to a list of concrete packages.
+    print("started solving the environment")
+    solved_records = await solve(
+        # Channels to use for solving
+        channels=["conda-forge"],
+        # The specs to solve for
+        specs=["python ~=3.12.0", "pip", "requests 2.31.0"],
+        # Virtual packages define the specifications of the environment
+        virtual_packages=VirtualPackage.detect(),
+    )
+    print("solved required dependencies")
+
+    # Install the packages into a new environment (or updates it if it already
+    # existed).
+    env_path = tempfile.mkdtemp()
+    await install(
+        records=solved_records,
+        target_prefix=env_path,
+    )
+
+    print(f"created environment: {env_path}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+</details>
+
+### Javascript
+
+To use the Javascript bindings, you can install the `@conda-org/rattler` package via npm. rattler is compiled to WebAssembly and can be used in the browser or in Node.js.
+
+```bash
+npm install @conda-org/rattler
+```
+
+Using rattler from Javascript is useful to get access to the same version comparison functions as used throughout the conda ecosystem. It is also used as part of [`mambajs`](https://github.com/emscripten-forge/mambajs) which uses the rattler library to solve and install packages from the emscripten-forge channel _in the browser_.
+
+
+## Give it a try!
+
+Before you begin, make sure you have the following prerequisites:
+- A recent version of [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
+- A recent version of [pixi](https://github.com/prefix-dev/pixi)
+
+Follow these steps to clone, compile, and run the rattler project:
+```shell
+# Clone the rattler repository along with its submodules:
+git clone --recursive https://github.com/conda/rattler.git
+cd rattler
+
+# Compile and execute rattler to create a JupyterLab instance:
+pixi run rattler create jupyterlab
+```
+
+The above command will execute the `rattler` executable in release mode.
+It will download and install an environment into the `.prefix` folder that contains [`jupyterlab`](https://jupyterlab.readthedocs.io/en/stable/getting_started/overview.html) and all the dependencies required to run it (like `python`)
+
+Run the following command to start jupyterlab:
+
+```shell
+# on windows
+.\.prefix\Scripts\jupyter-lab.exe
+
+# on linux or macOS
+ ./.prefix/bin/jupyter-lab
+```
+
+Voila!
+You have a working installation of jupyterlab installed on your system!
+You can of course install any package you want this way.
+Try it!
+
+## Contributing 😍
+
+We would love to have you contribute!
+See the CONTRIBUTION.md for more info. For questions, requests or a casual chat, we are very active on our discord server.
+You can [join our discord server via this link][chat-url].
+
+
+## Components
+
+Rattler consists of several crates that provide different functionalities.
+
+* **rattler_conda_types**: foundational types for all datastructures used within the conda eco-system.
+* **rattler_package_streaming**: provides functionality to download, extract and create conda package archives.
+* **rattler_repodata_gateway**: downloads, reads and processes information about existing conda packages from an index.
+* **rattler_shell**: code to activate an existing environment and run programs in it.
+* **rattler_solve**: a backend agnostic library to solve the package satisfiability problem.
+* **rattler_virtual_packages**: a crate to detect system capabilities.
+* **rattler_index**: create local conda channels from local packages.
+* **rattler**: functionality to create complete environments from scratch using the crates above.
+* **rattler-lock**: a library to create and parse lockfiles for conda environments.
+* **rattler-networking**: common functionality for networking, like authentication, mirroring and more.
+* **rattler-bin**: an example of a package manager using all the crates above (see: [showcase](#showcase))
+
+You can find these crates in the `crates` folder.
+
+Additionally, we provide Python bindings for most of the functionalities provided by the above crates.
+A python package `py-rattler` is available on [conda-forge](https://prefix.dev/channels/conda-forge/packages/py-rattler) and [PyPI](https://pypi.org/project/py-rattler/).
+Documentation for the python bindings can be found [here](https://conda.github.io/rattler/py-rattler).
+
+## What is conda & conda-forge?
+
+The conda ecosystem provides **cross-platform**, **binary** packages that you can use with **any programming language**.
+`conda` is an open-source package management system and environment management system that can install and manage multiple versions of software packages and their dependencies.
+`conda` is written in Python.
+The aim of Rattler is to provide all functionality required to work with the conda ecosystem from Rust.
+Rattler is not a reimplementation of `conda`.
+`conda` is a package management tool.
+Rattler is a _library_ to work with the conda ecosystem from different languages and applications.
+For example, it powers the backend of https://prefix.dev.
+
+`conda-forge` is a community-driven effort to bring new and existing software into the conda ecosystem.
+It provides _tens-of-thousands of up-to-date_ packages that are maintained by a community of contributors.
+For an overview of available packages see https://prefix.dev.
+

py_rattler-0.22.0.dist-info/RECORD

@@ -0,0 +1,68 @@
+py_rattler-0.22.0.dist-info/METADATA,sha256=efwJCkhVTceAjsvtsV8hoclHa9EtswPlRxM8ZFFHIXQ,9941
+py_rattler-0.22.0.dist-info/WHEEL,sha256=s8NxmDbYHddg5oVzZ4QZLSyBus4nl_93OiuRGzf4MbU,127
+rattler/__init__.py,sha256=YTtm1FQckDkkVJgeF-iR1hz8kmhR4b17biPFBycoS3E,2789
+rattler/channel/__init__.py,sha256=K-ZAo0qFzchXWP-6DpMHLg_djGD25-0CRwusisIGp8k,221
+rattler/channel/channel.py,sha256=kGeZKa_YkSM943CA1i_8O1FXG9kS9hkrnmSl6OhkbbQ,2474
+rattler/channel/channel_config.py,sha256=rRD4dGeHTBIcm3vTuQR1wTGTELNdN69yq4lyCaTaN3M,1532
+rattler/channel/channel_priority.py,sha256=OQfCHp_DeInkMB0YahCf2X7yCk0_RtM_C_Vy4Ny-65M,474
+rattler/exceptions.py,sha256=Bkwdmc7Wt25wsSr7d84b3JTBBd8eYTyHlmdv0B5aO5M,4258
+rattler/explicit_environment/__init__.py,sha256=QHmwZkdVt-tFL-tEEdhLdH3apuI5F7ElpMzCRZeH3_o,170
+rattler/explicit_environment/environment.py,sha256=Dqcvm5c7C3K0FJ04YVN8WIUrl0R8Fe2TeXZ4Qq8Dg-0,2641
+rattler/index/__init__.py,sha256=X02qeNDYnyWR-J7FaAvNoQfw5DtYRbUGtNEq5nAva0Y,119
+rattler/index/index.py,sha256=37z_o9yXEdDyUfFDbwX5xmfI8tw0Y32RiVmVdAdym3A,4621
+rattler/install/__init__.py,sha256=F_DwKOql1YkdV78JV5jT0RglNhs2ZwSup9uWGv9wO4I,69
+rattler/install/installer.py,sha256=_0Z8PKUitbtnGHZfzZr9657QZIN_ji1LBucr3zVipTM,4226
+rattler/lock/__init__.py,sha256=JkighOKfDQBqX3xrw1NXYlA_j1IFNI47_s6p2XvFtQc,571
+rattler/lock/channel.py,sha256=PaLb-vWRLTJWUx7fyMdP2Tow5wMlGuq3WUrHkrQIzeg,1331
+rattler/lock/environment.py,sha256=sbcGqkb9rrGwpVCucDKkwdp2SFOyHZQGqvBArGEZFYs,7915
+rattler/lock/hash.py,sha256=qNig1sf5EfRfaCK9x352DgqTpLdo75Gu4qvRZDbL33Q,805
+rattler/lock/lock_file.py,sha256=6lwZPALFu53kIbh0Z6945_5yDhkTRFjGNGAgMmG_Ark,3463
+rattler/lock/package.py,sha256=FnjWrHfcgRgqZepCKuCDA7tuIa0INGF8ivGswkQ_17E,9024
+rattler/match_spec/__init__.py,sha256=uBV3ov1VlCIZlIWhkxxMPcTqRBF5p5lqvT2g6kQv5kQ,167
+rattler/match_spec/match_spec.py,sha256=JyMwVy21vIK66XBudbj6vnw-43hPfQ-n7UNPNdw-iso,10893
+rattler/match_spec/nameless_match_spec.py,sha256=TFemOm6kZ6Q4j3dBHusWRYzvubFfNVLcPSgHdrqs-mw,5366
+rattler/networking/__init__.py,sha256=s-20DnfLQ_YaMOmpVfBbJDjUEEZEHFPbVycvqkdWlNo,528
+rattler/networking/client.py,sha256=Gd4AjQhaepQbhV0S4DcqvOwu_jis2_LibTytVEO-L9I,1755
+rattler/networking/fetch_repo_data.py,sha256=ByZ0yH9WmYWvQ0soyXaPpulamCasc9EJfMGy-_ca_m8,3742
+rattler/networking/middleware.py,sha256=yxPGDr0Y4zxsfIL1_EtvwDhAONiOqVUTm2SVQuvYlBc,6298
+rattler/package/__init__.py,sha256=omXnLVICkiH7HiaUzpRWAaJxS955Uimm1pT8dejJgVU,624
+rattler/package/about_json.py,sha256=FElWUXFNeF1gQJXE6lmYNEdxQjhsuimVObIeqxn3y8M,8958
+rattler/package/index_json.py,sha256=BxnJg5SPpiFsLhabz-Uuvc4ea_sg4N7Q-hqdQnXk8oc,12419
+rattler/package/no_arch_type.py,sha256=y_1spiImY3654SDLRQWyp5mqr4l-gYKIuK4pCnEPj1s,3740
+rattler/package/package_name.py,sha256=4k9mzoYZnPQ5u4om1Vk_vq96waZwsHRvOXSmHtwMpAs,5985
+rattler/package/package_name_matcher.py,sha256=4MruLSx6fVtDkFqBHInUgs95v4rr7zaTyF8UT0BHXgQ,2545
+rattler/package/paths_json.py,sha256=7l2Wmqobwcoe-TStXhoafWzXCT4OWif_yAAa6KVnKyg,21465
+rattler/package/run_exports_json.py,sha256=fZlM_H7IBuVi6lfL4SLsV_NDb22TgFhpCkxjm8YIvfg,9305
+rattler/package_streaming/__init__.py,sha256=I-mbr0sJnHzdFQP8v0Yb_GKpu4bIO3JbAJtq_wzA71Q,898
+rattler/platform/__init__.py,sha256=YZaXxnJmG_WjYbhIAxA0jQDhaPYAR4rTVQCm4yRoyZQ,154
+rattler/platform/arch.py,sha256=quY41vZordAaVGc-Y-ZR55mE8aHTpwWGqbUE9162OWs,1164
+rattler/platform/platform.py,sha256=lkAB62zEzglAs3wZZfW5sujiRAbxr1On5SKcmr8HbuA,4900
+rattler/prefix/__init__.py,sha256=gkgyqZ0yTmxOCW8DHuSG-X0spEzb8BIoiox8YG50XYc,257
+rattler/prefix/prefix_paths.py,sha256=B0EwOFkVbSzuLChdjkjenTehfxjXwwMBIodSGOfBHFU,12828
+rattler/prefix/prefix_record.py,sha256=1ALSRxHlhkOAl86_HKhU_l-Ny0PK11je6rnHo9alfh8,7048
+rattler/pty/__init__.py,sha256=lIoecUQnscJ1tui5XvyIiVFcqtxB-jpZsA1PeXDKO7Q,794
+rattler/pty/pty_process.py,sha256=rHaWqdE38kDt4nWaX34N8hfR-ShsfB_haqnMdEkA4IU,11583
+rattler/pty/pty_session.py,sha256=Gmj2FBC9bW5ua7t523T9bJNwqe5q8sqDu61t6Y_D0ws,7329
+rattler/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rattler/rattler.abi3.so,sha256=JT-6aNj8R7KdQC5GhAeWmiIhE4DbitZvQ642d-MAhRM,52157720
+rattler/repo_data/__init__.py,sha256=u0DmgChUgNwYkqNGKNioA0NXCbCbFQMuBaISuiHJEtQ,623
+rattler/repo_data/gateway.py,sha256=tPW3Q4-7dtUiKvUWdrnO96U4k4I3NFpMyj6YPky2k8E,13348
+rattler/repo_data/package_record.py,sha256=MB1ppI89VS4ZDS8CfUCIPhTDoixO1Cs5Cf_nTuYR3xA,28333
+rattler/repo_data/patch_instructions.py,sha256=TNa7NgLtqGQ6lSpibLFxuPFwsmqRLrORpDZOpeZ5fnk,694
+rattler/repo_data/record.py,sha256=uVmesHhEzll4CKmLnNdTh3GXMO66x_dmG49djJjKcho,4587
+rattler/repo_data/repo_data.py,sha256=39VnTUVCwXDy22FD1UluA3MGyzUYw2rLY9G91u-28TE,2261
+rattler/repo_data/source.py,sha256=WHpXXnZ0At0ciWothXcCau9vYJCO1oLsdW6snX1WBa4,2959
+rattler/repo_data/sparse.py,sha256=sdJFI_PDNgMCPjMm7MdkOwB7DKvoUTgZtevuR5M6uoI,12772
+rattler/shell/__init__.py,sha256=GW5Amfmw7ln9l4kBBZCelaJxYBP5xbk5NjdNLMZhNMU,179
+rattler/shell/shell.py,sha256=FJ1Hd3fMQSCd7jNHmpPOR3wIKlADdNZTZZW42lkNTY0,4543
+rattler/solver/__init__.py,sha256=NZabrelb_pcqOi5PyZTr3OeBbjd85IqW1-2ymOBO-k0,119
+rattler/solver/solver.py,sha256=MzSbNs4Ui88Hbtt6sHD5dRX3ZLkWqrzOLE5lxy57d7E,11614
+rattler/utils/rattler_version.py,sha256=eXAVN6NYg5EmsQ_DrfgxW1yJ_eWAlWx7IANasMRYgV4,526
+rattler/version/__init__.py,sha256=n8wi1-mw4AgaEHzUoc-pG0l-7G0665TMMsEKb-fSHBA,214
+rattler/version/version.py,sha256=5CWe2wjH-7lmKUgzFFMSfNwLF04lzLgarhckkmdQ4cY,15954
+rattler/version/version_spec.py,sha256=Ymhcz73uEre1-n3TBIdFz3W6YXBE4UfcAdzNqNe-4dU,4820
+rattler/version/with_source.py,sha256=nEW_jetdsB-5hKnxHVYgwOsd0EAe0fNKaCLlD4fIZiM,2539
+rattler/virtual_package/__init__.py,sha256=pOvvD-8V6Ld5gYBj2KPI3-cZLx8m2hcl6dqRUoBTHuw,262
+rattler/virtual_package/generic.py,sha256=ztDVHLNbO2SemZSpdoa2SdoXcZT1hopvBFQ11fNBZmQ,4411
+rattler/virtual_package/virtual_package.py,sha256=hrFvoT2LjIsW5ubfXdXEZnKlSIfLP5G4vrbJST9xukI,6707
+py_rattler-0.22.0.dist-info/RECORD,,

py_rattler-0.22.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.6)
+Root-Is-Purelib: false
+Tag: cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64

rattler/__init__.py

@@ -0,0 +1,114 @@
+from rattler.version import Version, VersionSpec, VersionWithSource
+from rattler.match_spec import MatchSpec, NamelessMatchSpec
+from rattler.repo_data import (
+    PackageRecord,
+    RepoData,
+    RepoDataRecord,
+    PatchInstructions,
+    SparseRepoData,
+    Gateway,
+    SourceConfig,
+    PackageFormatSelection,
+    RepoDataSource,
+)
+from rattler.channel import Channel, ChannelConfig, ChannelPriority
+from rattler.networking import Client, fetch_repo_data
+from rattler.virtual_package import GenericVirtualPackage, VirtualPackage, VirtualPackageOverrides, Override
+from rattler.package import (
+    PackageName,
+    AboutJson,
+    RunExportsJson,
+    PathsJson,
+    PathsEntry,
+    PathType,
+    PrefixPlaceholder,
+    FileMode,
+    IndexJson,
+    NoArchType,
+    NoArchLiteral,
+)
+from rattler.prefix import PrefixRecord, PrefixPaths, PrefixPathsEntry, PrefixPathType, Link, LinkType
+from rattler.platform import Platform
+from rattler.utils.rattler_version import get_rattler_version as _get_rattler_version
+from rattler.install import install
+from rattler.index import index
+from rattler.lock import (
+    LockFile,
+    Environment,
+    LockChannel,
+    PackageHashes,
+    LockedPackage,
+    CondaLockedSourcePackage,
+    CondaLockedBinaryPackage,
+    CondaLockedPackage,
+    PypiLockedPackage,
+)
+from rattler.solver import solve, solve_with_sparse_repodata
+
+__version__ = _get_rattler_version()
+del _get_rattler_version
+
+__all__ = [
+    "Version",
+    "VersionSpec",
+    "VersionWithSource",
+    "MatchSpec",
+    "NamelessMatchSpec",
+    "PackageRecord",
+    "Channel",
+    "ChannelConfig",
+    "ChannelPriority",
+    "Client",
+    "PatchInstructions",
+    "RepoDataRecord",
+    "RepoData",
+    "fetch_repo_data",
+    "GenericVirtualPackage",
+    "VirtualPackage",
+    "VirtualPackageOverrides",
+    "Override",
+    "PackageName",
+    "PrefixRecord",
+    "PrefixPaths",
+    "PrefixPathsEntry",
+    "PrefixPathType",
+    "SparseRepoData",
+    "PackageFormatSelection",
+    "LockFile",
+    "Environment",
+    "LockChannel",
+    "PackageHashes",
+    "LockedPackage",
+    "CondaLockedSourcePackage",
+    "CondaLockedBinaryPackage",
+    "CondaLockedPackage",
+    "PypiLockedPackage",
+    "solve",
+    "solve_with_sparse_repodata",
+    "Platform",
+    "install",
+    "index",
+    "AboutJson",
+    "RunExportsJson",
+    "PathsJson",
+    "PathsEntry",
+    "PathType",
+    "PrefixPlaceholder",
+    "FileMode",
+    "IndexJson",
+    "Gateway",
+    "SourceConfig",
+    "RepoDataSource",
+    "NoArchType",
+    "NoArchLiteral",
+    "Link",
+    "LinkType",
+]
+
+# PTY support - only available on Unix platforms
+try:
+    from rattler.pty import PtySession, PtyProcess, PtyProcessOptions  # noqa: F401
+
+    __all__.extend(["PtySession", "PtyProcess", "PtyProcessOptions"])
+except ImportError:
+    pass

rattler/channel/__init__.py

@@ -0,0 +1,5 @@
+from rattler.channel.channel import Channel
+from rattler.channel.channel_config import ChannelConfig
+from rattler.channel.channel_priority import ChannelPriority
+
+__all__ = ["Channel", "ChannelConfig", "ChannelPriority"]

rattler/channel/channel.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from rattler.lock.channel import LockChannel
+
+from rattler.rattler import PyChannel
+from rattler.channel.channel_config import ChannelConfig
+
+
+class Channel:
+    def __init__(self, name: str, channel_configuration: Optional[ChannelConfig] = None) -> None:
+        """
+        Create a new channel.
+
+        ```python
+        >>> channel = Channel("conda-forge")
+        >>> channel
+        Channel(name="conda-forge", base_url="https://conda.anaconda.org/conda-forge/")
+        >>>
+        ```
+        """
+        if not channel_configuration:
+            channel_configuration = ChannelConfig()
+
+        self._channel = PyChannel(name, channel_configuration._channel_configuration)
+
+    @classmethod
+    def _from_py_channel(cls, py_channel: PyChannel) -> Channel:
+        channel = cls.__new__(cls)
+        channel._channel = py_channel
+        return channel
+
+    def to_lock_channel(self) -> LockChannel:
+        """
+        Returns a new [`LockChannel`] from existing channel.
+
+        ```python
+        >>> channel = Channel("conda-forge")
+        >>> channel.to_lock_channel()
+        LockChannel(url="https://conda.anaconda.org/conda-forge/")
+        >>>
+        ```
+        """
+        from rattler.lock.channel import LockChannel
+
+        return LockChannel(self.base_url)
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        Return the name of this channel.
+
+        Examples
+        --------
+        ```python
+        >>> channel = Channel("conda-forge")
+        >>> channel.name
+        'conda-forge'
+        >>>
+        ```
+        """
+        return self._channel.name
+
+    @property
+    def base_url(self) -> str:
+        """
+        Return the base URL of this channel.
+
+        Examples
+        --------
+        ```python
+        >>> channel = Channel("conda-forge")
+        >>> channel.base_url
+        'https://conda.anaconda.org/conda-forge/'
+        >>>
+        ```
+        """
+        return self._channel.base_url
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of this channel.
+
+        Examples
+        --------
+        ```python
+        >>> channel = Channel("conda-forge")
+        >>> channel
+        Channel(name="conda-forge", base_url="https://conda.anaconda.org/conda-forge/")
+        >>>
+        ```
+        """
+        return f'Channel(name="{self.name}", base_url="{self.base_url}")'

rattler/channel/channel_config.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+import os
+from rattler.rattler import PyChannelConfig
+
+
+class ChannelConfig:
+    def __init__(self, channel_alias: str = "https://conda.anaconda.org/", root_dir: str = os.getcwd()) -> None:
+        """
+        Create a new channel configuration.
+
+        Examples
+        --------
+        ```python
+        >>> channel_config = ChannelConfig()
+        >>> channel_config # doctest: +ELLIPSIS
+        ChannelConfig(channel_alias="https://conda.anaconda.org/", ...
+        >>> channel_config = ChannelConfig("https://repo.prefix.dev/", "/path/to/root/dir")
+        >>> channel_config
+        ChannelConfig(channel_alias="https://repo.prefix.dev/", root_dir="/path/to/root/dir")
+        >>>
+        ```
+        """
+        if root_dir is None:
+            # Use the current working directory as the root directory.
+            root_dir = os.getcwd()
+        self._channel_configuration = PyChannelConfig(channel_alias, root_dir)
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of this channel configuration.
+
+        Examples
+        --------
+        ```python
+        >>> channel_config = ChannelConfig()
+        >>> channel_config # doctest: +ELLIPSIS
+        ChannelConfig(channel_alias="https://conda.anaconda.org/", root_dir="...
+        >>>
+        ```
+        """
+        alias = self._channel_configuration.channel_alias
+        root_dir = self._channel_configuration.root_dir
+        return f'ChannelConfig(channel_alias="{alias}", root_dir="{root_dir}")'

rattler/channel/channel_priority.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+from rattler.rattler import PyChannelPriority
+
+
+class ChannelPriority(Enum):
+    """
+    Defines how priority of channels functions during solves. If strict, the channel that the package is first
+    found in will be used as the only channel for that package. If disabled, then packages can be retrieved from
+    any channel as package version takes precedence.
+    """
+
+    Strict = PyChannelPriority.Strict
+    Disabled = PyChannelPriority.Disabled

rattler/exceptions.py

@@ -0,0 +1,120 @@
+try:
+    from rattler.rattler import (
+        InvalidVersionError,
+        InvalidVersionSpecError,
+        InvalidMatchSpecError,
+        InvalidPackageNameError,
+        InvalidUrlError,
+        InvalidChannelError,
+        ActivationError,
+        ParsePlatformError,
+        ParseArchError,
+        TransactionError,
+        LinkError,
+        IoError,
+        DetectVirtualPackageError,
+        CacheDirError,
+        FetchRepoDataError,
+        SolverError,
+        ConvertSubdirError,
+        VersionBumpError,
+        EnvironmentCreationError,
+        ExtractError,
+        GatewayError,
+        ValidatePackageRecordsException,
+    )
+except ImportError:
+    # They are only redefined for documentation purposes
+    # when there is no binary yet
+
+    class InvalidVersionError(Exception):  # type: ignore[no-redef]
+        """Error that can occur when parsing a Version"""
+
+    class InvalidVersionSpecError(Exception):  # type: ignore[no-redef]
+        """Error that can occur when parsing a VersionSpec"""
+
+    class InvalidMatchSpecError(Exception):  # type: ignore[no-redef]
+        """Error that can occur when parsing a MatchSpec"""
+
+    class InvalidPackageNameError(Exception):  # type: ignore[no-redef]
+        """Error that can occur when parsing a package name"""
+
+    class InvalidUrlError(Exception):  # type: ignore[no-redef]
+        """Error that can occur when parsing a URL"""
+
+    class InvalidChannelError(Exception):  # type: ignore[no-redef]
+        """Error that can occur when parsing a channel."""
+
+    class ActivationError(Exception):  # type: ignore[no-redef]
+        """Error that can occur when activating a conda environment"""
+
+    class ParsePlatformError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when parsing a platform from a string."""
+
+    class ParseArchError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when parsing an arch from a string."""
+
+    class TransactionError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when executing a transaction"""
+
+    class LinkError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when linking a package"""
+
+    class IoError(Exception):  # type: ignore[no-redef]
+        """An error that can occur during io operations"""
+
+    class DetectVirtualPackageError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when trying to detect virtual packages"""
+
+    class CacheDirError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when querying the cache directory"""
+
+    class FetchRepoDataError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when fetching repo data"""
+
+    class SolverError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when trying to solve an environment"""
+
+    class ConvertSubdirError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when parsing a platform from a string."""
+
+    class VersionBumpError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when bumping a version."""
+
+    class EnvironmentCreationError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when creating an environment."""
+
+    class ExtractError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when extracting an archive."""
+
+    class GatewayError(Exception):  # type: ignore[no-redef]
+        """An error that can occur when querying the repodata gateway."""
+
+    class ValidatePackageRecordsException(Exception):  # type: ignore[no-redef]
+        """An error when validating package records."""
+
+
+__all__ = [
+    "ActivationError",
+    "CacheDirError",
+    "DetectVirtualPackageError",
+    "FetchRepoDataError",
+    "InvalidChannelError",
+    "InvalidMatchSpecError",
+    "InvalidPackageNameError",
+    "InvalidUrlError",
+    "InvalidVersionError",
+    "InvalidVersionSpecError",
+    "IoError",
+    "LinkError",
+    "ParseArchError",
+    "ParsePlatformError",
+    "SolverError",
+    "TransactionError",
+    "ConvertSubdirError",
+    "VersionBumpError",
+    "EnvironmentCreationError",
+    "ExtractError",
+    "GatewayError",
+    "ValidatePackageRecordsException",
+]