semvec/pypi-packages huggingface dataset:
sagar-varma 0.1.4
A simple terminal-based snake game.

# TSnake

A simple terminal-based snake game written in Python.

## Prerequisites

On Linux, you will need to install the `ncurses` development headers:

*   **Debian/Ubuntu:** `sudo apt-get install libncurses5-dev`
*   **Fedora/CentOS:** `sudo yum install ncurses-devel`

## Installation

```bash
pip install tsnake
```

## Usage

```bash
tsnake
```
numanalysis 0.1.1
Package for LU decomp
Requires Python: >=2.7

# NumAnalysis

NumAnalysis is a Python library for basic numerical linear algebra operations.  
It currently provides functions for LU decomposition and Cholesky decomposition, with checks for matrix properties (square, symmetric, positive definite, etc.).  
The library is designed to grow and include more numerical analysis tools over time.

---
source code : https://github.com/1030minouche/numanalysis
## Installation

You can install NumAnalysis from PyPI (once published):

```bash
pip install numanalysis
jitter00-jinfo 0.2.8
Juniper device information retrieval tool via NETCONF
Requires Python: >=3.8

# Jinfo - Juniper Device Information Tool

A Python CLI tool that connects to Juniper devices via NETCONF and retrieves software version information.

## Features

- Connect to Juniper devices via NETCONF
- Retrieve software version information
- Output results in JSON format
- SSH key-based authentication (no password required)

## Requirements

- Python 3.10 or higher
- SSH key configured on the Juniper device for the user running the script
- NETCONF enabled on the target Juniper device

## Installation

Install the required dependencies:

```bash
pip install -e .
```

## Usage

After installation, use the `jinfo` command:

```bash
jinfo <device-hostname>
```

### Arguments

- `hostname`: Juniper device hostname or IP address (required)

### Examples

```bash
# Connect to a device
jinfo router1.example.com

# Connect using IP address
jinfo 192.168.1.1

# Connect to any Juniper device
jinfo juniper-device
```

### Output

The tool outputs software version information in JSON format:

```json
{
  "host-name": "router1",
  "product-model": "MX480",
  "junos-version": "21.2R3-S1.7"
}
```

## Configuration

Before running the tool, ensure:

1. Your SSH public key is added to the Juniper device
2. NETCONF is enabled on the device:
   ```
   set system services netconf ssh
   commit
   ```
3. The device is reachable on the specified port (default: 830)

## Versioning

This project uses [Semantic Versioning](https://semver.org/) based on [Conventional Commits](https://www.conventionalcommits.org/). 

Versions are automatically determined from commit messages:
- `feat:` → Minor version bump (0.1.0 → 0.2.0)
- `fix:` → Patch version bump (0.1.0 → 0.1.1)
- `feat!:` or `BREAKING CHANGE:` → Major version bump (0.1.0 → 1.0.0)

See [SEMANTIC_VERSIONING.md](SEMANTIC_VERSIONING.md) for detailed information.

## License

MIT
# Test
# Test feature
# Trigger release
# Test
kivy-garden.ebs.camera 1.2.0
Camera Preview Widgets for Kivy
Keywords: Kivy kivy-garden

Camera Widgets for Kivy
=======================

[![Github Build Status](https://github.com/ebs-universe/kivy_garden.ebs.clocks/workflows/Garden%20flower/badge.svg)](https://github.com/ebs-universe/kivy_garden.ebs.clocks/actions)

This package provides relatively simple Camera widgets for Kivy. 

This package is part of the EBS widget collection for Kivy. It is written in 
mostly Python and depends on the EBS core widgets and widget infrastructure package. 
For more information, see [kivy_garden.ebs.core](https://github.com/ebs-universe/kivy_garden.ebs.core)

See https://kivy-garden.github.io/ebs.flower/ for the rendered flower docs.

Please see the garden [instructions](https://kivy-garden.github.io) for 
how to use kivy garden flowers.


CI
--

Every push or pull request run the [GitHub Action](https://github.com/kivy-garden/flower/actions) CI.
It tests the code on various OS and also generates wheels that can be released on PyPI upon a
tag. Docs are also generated and uploaded to the repo as well as artifacts of the CI.


TODO
-------

* add your code

Contributing
--------------

Check out our [contribution guide](CONTRIBUTING.md) and feel free to improve the flower.

License
---------

This software is released under the terms of the MIT License.
Please see the [LICENSE.txt](LICENSE.txt) file.

How to release
===============

See the garden [instructions](https://kivy-garden.github.io/#makingareleaseforyourflower) for how to make a new release.
wave-simulator 0.0.2
wave simulator
Requires Python: >=3.9

# Wave Simulator

[中文](./readme_zh.md)

This project is for wave simulation.

> **Please do not use this project for any purpose other than learning, as the author does not guarantee its rigor.**

## Installation

```bash
pip install wave-simulator
```

## Examples

The following is a simple example. You can find more examples [here](./examples/).

```python
from wave_simulator import OneDimensionSimulator, FixedBoundary

def my_initial_wave(x):
    if x < 4:
        return 0.5*x
    return -x + 6

s = OneDimensionSimulator()
s.set_simulation_range(6, 0.01, 16, 0.001)
s.set_initial_wave(my_initial_wave)
s.set_left_boundary(FixedBoundary())
s.set_right_boundary(FixedBoundary())
s.simulate()
s.animate_result_1D(ylim=(-4, 4), down_sampling_rate=20)
```

## Detailed Guide

You can set the simulation's spatial and temporal ranges. This setting should be done before other configurations.

```python
s.set_simulation_range(6, 0.01, 16, 0.001)
```

Set the initial waveform

```python
def my_initial_wave(x):
    if x < 4:
        return 0.5*x
    return -x + 6

s.set_initial_wave(my_initial_wave)
```

Set the initial speed of the particles

```python
def my_initial_speed(x):
    if x > 0.1 and x < np.pi/4+0.1:
        return -8*np.cos(8*(x-0.1))
    return 0

s.set_initial_point_speed(my_initial_speed)
```

Set the wave speed

```python
def my_wave_speed(x):
    if x > 1.5:
        return 0.5
    return 1

s.set_wave_speed(my_wave_speed)
```

Set boundary conditions

```python
s.set_left_boundary(FixedBoundary())
s.set_right_boundary(FixedBoundary())
s.set_up_boundary(UnlimitedBoundary())
s.set_down_boundary(NeumannBoundary())
```

To save the simulation result as a video, just add a `save_path` parameter

```python
s.animate_result_3D(save_path="your_path.mp4")
```

## Correspondence between Mathematical Symbols and Code Variables

| Variable Name | Meaning                |
| ------------- | ---------------------- |
| `L_x`         | Simulation range for x |
| `dx`          | Spatial step for x     |
| `X`           | Discrete values for x  |
| `c`           | Wave speed             |
| `c2`          | $c^2$                  |
| `C`           | $c\frac{dt}{dx}$       |
| `C2`          | $(c\\frac{dt}{dx})^2 $ |
| `c2_i_sub_1`  | $c_{i-1}^2$            |
| `c2_i`        | $c_i^2$                |
| `c2_i_add_1`  | $c_{i+1}^2$            |
| `u_i_sub_1`   | $u_{i-1}$              |
| `u_i`         | $u_{i}$                |
| `u_i_add_1`   | $u_{i+1}$              |
| `u_i_j`       | $u_{i,j}$              |
| `u_ip1_j`     | $u_{i+1,j}$            |
| `u_is1_j`     | $u_{i-1,j}$            |
| `u_i_ja1`     | $u_{i,j+1}$            |
| `u_i_js1`     | $u_{i,j-1}$            |

## Related Formulas

[1d reference](https://www.google.com/search?q=./readme_1d.md)
[2d reference](https://www.google.com/search?q=./readme_2d.md)
artmeta 0.2.5
Gestionnaire de métadonnées pour articles académiques - génération LaTeX et exports HAL/ArXiv
Requires Python: >=3.8
Keywords: latex, academic, metadata, hal, arxiv, publishing

# artmeta

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
[![pipeline status](https://plmlab.math.cnrs.fr/nicolas.klutchnikoff/artmeta/badges/main/pipeline.svg)](https://plmlab.math.cnrs.fr/nicolas.klutchnikoff/artmeta/-/pipelines)
[![coverage report](https://plmlab.math.cnrs.fr/nicolas.klutchnikoff/artmeta/badges/main/coverage.svg)](https://plmlab.math.cnrs.fr/nicolas.klutchnikoff/artmeta/-/pipelines)
[![PyPI version](https://badge.fury.io/py/artmeta.svg)](https://badge.fury.io/py/artmeta) <!-- Placeholder : à activer lors de la publication sur PyPI -->
[![Documentation Status](https://readthedocs.org/projects/artmeta/badge/?version=latest)](https://artmeta.readthedocs.io/en/latest/?badge=latest)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

**Gérez les métadonnées de vos articles scientifiques sans effort.**

`artmeta` est un outil en ligne de commande qui vous libère de la gestion fastidieuse des métadonnées d'articles. Définissez auteurs, affiliations et résumé une seule fois dans un fichier YAML, et laissez `artmeta` générer le code LaTeX pour n'importe quelle revue.

### Concept

```
[ art.yml ] ----( artmeta )----> [ Code LaTeX / HAL XML ]
```

---

### Installation

```bash
pip install artmeta
```

### Exemple d'Utilisation

```bash
# 1. Initialisez votre fichier de métadonnées
artmeta init

# 2. Générez et insérez le code pour une revue (ex: AMS)
artmeta generate -j amsart --insert main.tex

# 3. Rejeté ? Changez de revue en une seule commande
artmeta switch -j elsarticle main.tex
```

---

### 📖 Documentation

Pour un guide complet, des exemples et des tutoriels, **[consultez la documentation](https://artmeta.readthedocs.io)**.

### 🤝 Contribuer

Les contributions sont les bienvenues ! Voir le **[guide de contribution](https://artmeta.readthedocs.io/en/latest/contributing/)**.

### 📄 Licence

Ce projet est sous licence [MIT](LICENSE).