semvec/pypi-packages huggingface dataset:
pyCribbageApp 0.1.4
pyCribbageApp is a python package that provides a tkinter based GUI for playing cribbage games using the CribbageSim package.
Requires Python: >=3.12
Keywords: GUI, cribbage, tkinter, desktop

# pyCribbageApp

Source code: [GitHub](https://github.com/KevinRGeurts/pyCribbageApp)
---
pyCribbageApp is a python package that provides a tkinter based GUI for playing cribbage games using the CribbageSim package.

## Requirements

- tkAppFramework>=0.9.3: [GitHub](https://github.com/KevinRGeurts/tkAppFramework), [PyPi](https://pypi.org/project/tkAppFramework/)
- CribbageSim>=1.0.2: [GitHub](https://github.com/KevinRGeurts/CribbageSim), [PyPi](https://pypi.org/project/CribbageSim/)

## Basic usage

The simplest way to run the app is:

```
python -m pyCribbageApp.CribbageApp 
```

This assumes that the required packages are installed. To learn how to use the app, select Help | View Help... from the menu bar.

## Unittests

Unittests for the pyCribbageApp package are in the tests directory, with filenames starting with test_. To run the unittests,
type ```python -m unittest discover -s ..\..\tests -v``` in a terminal window in the src\pyCribbageApp directory.

## License

MIT License. See the LICENSE file for details
baccoemu 2.3.0
A collection of cosmological emulators for large-scale structure statistics
Requires Python: >=3.9

# THE BACCO EMULATORS

baccoemu provides a collection of emulators for large-scale structure statistics over a wide range of
cosmologies.

## Installation

Follow detailed instructions at https://baccoemu.readthedocs.io/en/latest/#installation

Anyway, a quick installation should boil down to

```bash
pip install . [--user]
```

## Usage

Follow detailed instructions at https://baccoemu.readthedocs.io/en/latest/#quickstart

You can also find examples and tutorials in the examples and notebooks folders.

## Credit our work

If you use baccoemu, please cite our papers:

- the `linear cold- and total-matter power spectrum <https://arxiv.org/abs/2104.14568>`_
- the `nonlinear cold-matter power spectrum <https://arxiv.org/abs/2004.06245> and <https://arxiv.org/pdf/2303.05537>`_
- the `modifications to the cold-matter power spectrum caused by baryonic physics <https://arxiv.org/abs/2011.15018> and <https://arxiv.org/pdf/2506.18974>`_
- the `modifications to the cold-matter bispectrum caused by baryonic physics <https://arxiv.org/abs/2506.18974>`_
- the `nonlinear biased tracers in real space <https://arxiv.org/abs/2101.12187>`_
- the `nonlinear biased tracers in redshift space <https://arxiv.org/abs/2207.06437>`_

For more details, visit our `our website <http://bacco.dipc.org>`_

## License
[MIT](https://choosealicense.com/licenses/mit/)
pathrs 0.2.3
Python bindings for libpathrs, a safe path resolution library for Linux.
Requires Python: >=3.9
Keywords: libpathrs, pathrs

## python-pathrs ##

This is a basic Python wrapper around [libpathrs][libpathrs], a safe path
resolution library for Linux. For more details about the security protections
provided by [libpathrs][libpathrs], [see the main README][libpathrs-readme].

In order to use this library, you need to have `libpathrs.so` installed on your
system. Your distribution might already have a libpathrs package. If not, you
can [install libpathrs from source][libpathrs].

### Examples ###

libpathrs allows you to operate on a container root filesystem safely, without
worrying about an attacker swapping components and tricking you into operating
on host files.

```python
import pathrs

# Get a handle to the root filesystem.
with pathrs.Root("/path/to/rootfs") as root:
    # Get an O_PATH handle to a path we want to operate on.
    with root.resolve("/etc/passwd") as passwd:
        # Upgrade the handle to one you can do regular IO on.
        with root.reopen("r") as f:
            for line in f:
                print(line.rstrip("\n"))
```

Aside from just opening files, libpathrs also allows you to do most common
filesystem operations:

```python
import pathrs

# <fcntl.h>
RENAME_EXCHANGE = 0x2

with pathrs.Root("/path/to/rootfs") as root:
    # symlink
    root.symlink("foo", "bar") # foo -> bar
    # link
    root.hardlink("a", "b") # a -> b
    # rename(at2)
    root.rename("foo", "b", flags=RENAME_EXCHANGE) # foo <-> b
    # open(O_CREAT)
    with root.creat("newfile", "w+") as f:
        f.write("Some contents.")
```

It also supports operations like `mkdir -p` and `rm -f`, which are a little
tricky to implement safely.

```python
import pathrs

with pathrs.Root("/path/to/rootfs") as root:
    # rm -r
    root.remove_all("/tmp/foo")
    # mkdir -p
    root.mkdir_all("/tmp/foo/bar/baz/bing/boop", 0o755)
```

In addition, libpathrs provides a safe `procfs` API, to allow for privileged
programs to operate on `/proc` in a way that detects a maliciously-configured
mount table. This is a somewhat esoteric requirement, but privileged processes
that have to operate in untrusted mount namespaces need to handle this
properly or risk serious security issues.

```python
from pathrs import procfs

# readlink("/proc/thread-self/fd/0")
stdin_path = procfs.readlink(procfs.PROC_THREAD_SELF, "fd/0")

# readlink("/proc/self/exe")
exe_path = procfs.readlink(procfs.PROC_SELF, "exe")

# Read data from /proc/cpuinfo.
with procfs.open(procfs.PROC_ROOT, "cpuinfo", "r") as cpuinfo:
    for line in cpuinfo:
        print(line.rstrip("\n"))
```

For more information about the libpathrs API and considerations you should have
when using libpathrs, please see [the Rust documentation][libpathrs-rustdoc].

[libpathrs]: https://github.com/cyphar/libpathrs
[libpathrs-readme]: https://github.com/cyphar/libpathrs/blob/main/README.md
[libpathrs-rustdoc]: https://docs.rs/pathrs
hew 0.6.0
Hew is a specification and reference implementations to compile repository changelogs into release notes and other forms of documentation.
Requires Python: >=3.11
Keywords: changelog, documentation, git, release-notes

# Hew (Python implementation)

The Hew [changelog specification](https://codeberg.org/hew/spec) reference implementation for the Python language.

## Getting Started

Pending release to distribution channels like PyPi, you may run the program locally with `uv`.
A [nix](https://nixos.org/) devshell is present if you'd prefer to enter that managed environment with `nix develop .`.

Without nix, you will also need to obtain and install [Pandoc](https://pandoc.org/) to use the formatting translation features of `hew`.

## Usage

`hew` Python supports two primary modes of operation: as a native library and as a command-line utility.

### CLI

Use the executable command line interface if you'd like to use the Python program as a utility and work primarily with the output of the parsing results, usually JSON.

```python
uv run hew --help
```

Consult the help text to learn about supported flags and their effects.

### Library

After installing `hew` into a Python environment, instantiate the `Hewer` class with the necessary constructor arguments:

```python
Hewer(...)
```

### Validation

Clone with the submodule and use its `spec/repo-gen.sh` script along with the sibling `repo-spec.json` file to generate a sample repository with Hew-compliant changelogs and compare the results with the expected JSON results.

The `./scripts/validate.py` file is available to facilitate this process.

```shell
uv run python scripts/validate.py spec/repo-gen.sh spec/repo-spec.json
```

This will:

- Invoke `repo-gen.sh` in a temporary directory
- Run Hew inside the directory to generate a changelog manifest
- Compare it (excluding unique fields like timestamps) against the given specification JSON
- Ensure the results match the specification
kuest-py-order-utils 0.3.3
Python utilities used to generate and sign orders for the Kuest CTF Exchange
Requires Python: >=3.9.10

## Kuest CLOB Python order-utils

<a href='https://pypi.org/project/kuest-py-order-utils'>
    <img src='https://img.shields.io/pypi/v/kuest-py-order-utils.svg' alt='PyPI'/>
</a>

Python utilities used to generate and sign orders for the Kuest CTF Exchange

### Install

```bash
pip install kuest-py-order-utils
```

### Usage

```py
from py_order_utils.builders import OrderBuilder
from py_order_utils.signer import Signer
from pprint import pprint

def main():
    exchange_address = "0x...."
    chain_id = 80002
    signer = Signer("0x....")
    builder = OrderBuilder(exchange_address, chain_id, signer)

    # Create and sign the order
    order = builder.build_signed_order(
        OrderData(
            ...
        )
    )

    # Generate the Order and Signature json to be sent to the CLOB API
    pprint(json.dumps(order.dict()))

```
magnum-cluster-api 0.35.0
Cluster API driver for Magnum
Requires Python: >=3.10

![Cluster API driver for Magnum](docs/static/logo.png?raw=true "Cluster API driver for Magnum")

The Cluster API driver for Magnum allows you to deploy fully conformant
Kubernetes cluster using the [Cluster API](https://cluster-api.sigs.k8s.io/)
project which are fully integrated with the OpenStack cluster they are running
on.

For more information, please refer to the following resources:

* **Documentation**: https://vexxhost.github.io/magnum-cluster-api/
* **Community**: [`#magnum-cluster-api`](https://kubernetes.slack.com/archives/C05Q8TDTK6Z) channel
  on the Kubernetes Slack. If you are new to Kubernetes Slack workspace,
  [Join the Kubernetes Slack workspace](https://slack.kubernetes.io/) first.

## Images

The Cluster API driver for Magnum relies on specific OpenStack images containing
all necessary dependencies for deploying Kubernetes clusters.

For more information on how to build images and where to find pre-built images,
refer to the [user guide](https://vexxhost.github.io/magnum-cluster-api/user/images/)

## Testing & Development

For more information on how to test, develop and contribute to the Cluster API
driver for Magnum, refer to the [developer guide](https://vexxhost.github.io/magnum-cluster-api/developer/testing-and-development/).
CribbageSim 1.0.2
CribbageSim is a Cribbage card game simulator that can be played interactively or automatically to generate game-play statistics.
Requires Python: >=3.12
Keywords: console, desktop, simulator, cribbage, game

# CribbageSim

Source code: [GitHub](https://github.com/KevinRGeurts/CribbageSim)
---
CribbageSim is a Python implementation of the Cribbage card game. It allows interactive play with one human player against one computer player.
It also includes a simulation mode where both players are played by the computer. Simulation mode can be used
to analyze different player strategies and to generate game-play statistics. In simulation mode, as deployed, the players use
a play strategy based on that described by Hoyle's Rules of Games, supplemented with experience of the developer.

## Credit where credit is due

- The Strategy design pattern is used to implement both playing strategies and scoring card combinations, and follows the concepts, UML diagrams, and examples provided in
  "Design Patterns: Elements of Reusable Object-Oriented Software," by Eric Gamma, Richard Helm, Ralph Johnson,
  and John Vlissides, published by Addison-Wesley, 1995.
- The ```HoyleishCribbagePlayStrategy``` class implements a player strategy that is similar to the one described in "Hoyle's Rules of Games," by A.H. Morehead and G. Mott-Smith, second revised edition, published by Signet, 1983. However, significant additions have been made based on the experience of the developer.

## Requirements
- UserResponseCollector>=1.1.0: [GitHub](https://github.com/KevinRGeurts/UserResponseCollector), [PyPi](https://pypi.org/project/UserResponseCollector/)
- HandsDecksCards>=1.0.0: [GitHub](https://github.com/KevinRGeurts/HandsDecksCards), [PyPi](https://pypi.org/project/HandsDecksCards/)

## Usage
To play the game interactively or to run various simulations:
```
python -m CribbageSim.main
```
A menu of options for play and simulation will be presented.

## Unittests
Unit tests for CribbageSim have filenames starting with test_. To run the unit tests,
type ```python -m unittest discover -s .\..\tests -v``` in a terminal window in the project directory.

## License
MIT License. See the LICENSE file for details
GEOdb 0.2.0.1
An asynchronous Python library for the Gene Expression Omnibus (GEO) database
Requires Python: >=3.8
Keywords: bioinformatics, gene-expression-omnibus

# GEOdb
An asynchronous Python library for the Gene Expression Omnibus (GEO) database

## Usage

### parser

`from GEOdb.parser.series import parse_file, parse_item`

Either parse a file:

`parse_file('/path/to/GEO/downloaded.txt')`

Or parse a text:

```python
t = """1. Transcriptional profiling of human KIR+ CD8 T cells
(Submitter supplied) This SuperSeries is composed of the SubSeries listed below.
Organism:	Homo sapiens
Type:		Expression profiling by high throughput sequencing; Other
Platforms: GPL20301 GPL18573 4548 Samples
FTP download: GEO (TXT) ftp://ftp.ncbi.nlm.nih.gov/geo/series/GSE193nnn/GSE193442/
Series		Accession: GSE193442	ID: 200193442"""

parse_item(t)
```

```
GEOSeriesInfo(title='Transcriptional profiling of human KIR+ CD8 T cells',
              link='https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE193442',
              url='https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE193442',
              summary='(Submitter supplied) This SuperSeries is composed of '
                      'the SubSeries listed below.',
              organism='Homo sapiens',
              type='Expression profiling by high throughput sequencing; Other',
              platform='GPL20301',
              samples=4548,
              id='GSE193442',
              accession='GSE193442',
              series_id=200193442,
              ftp='ftp://ftp.ncbi.nlm.nih.gov/geo/series/GSE193nnn/GSE193442/',
              sra=None)
```
lazyad 0.0.109
make it easy to use ad api
Requires Python: >=3.8

# lazyad

#### 介绍
{**以下是 Gitee 平台说明，您可以替换此简介**
Gitee 是 OSCHINA 推出的基于 Git 的代码托管平台（同时支持 SVN）。专为开发者提供稳定、高效、安全的云端软件开发协作平台
无论是个人、团队、或是企业，都能够用 Gitee 实现代码托管、项目管理、协作开发。企业项目请看 [https://gitee.com/enterprises](https://gitee.com/enterprises)}

#### 软件架构
软件架构说明


#### 安装教程

1.  使用pip安装
- 普通方式安装
```shell script
pip3 install lazyad
```

- 使用阿里镜像加速安装
```shell script
pip3 install lazyad -i https://mirrors.aliyun.com/pypi/simple
```

2.  xxxx
3.  xxxx

#### 使用说明

1.  xxxx
2.  xxxx
3.  xxxx

#### 参与贡献

1.  Fork 本仓库
2.  新建 Feat_xxx 分支
3.  提交代码
4.  新建 Pull Request


#### 特技

1.  使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
2.  Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com)
3.  你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目
4.  [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目
5.  Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help)
6.  Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)