semvec/pypi-packages huggingface dataset:
xnode 1.4.0
This is a CLI management tool for MicroPython-based embedded systems.
Requires Python: >=3.8
Keywords: micropython, xnode, genlib

This is a CLI management tool for MicroPython-based XNode.

### Help
```sh
xnode
```
or
```sh
xnode --help
```

### Find serial port
```sh
xnode scan
```

### Option Rules
- Options and values can have spaces or omit spaces.
- Options and values can be inserted with the = character.

```sh
<option><value>  
<option> <value>
<option>=<value> 
```

### Initialize XNode file system (Only xnode type b)
```sh
xnode -s<com_port_name> init
```
or
```sh
xnode --sport<com_port_name> init
```
> \<com_port_name\> is the port number found by scan. 

### Check list of XNode file systems
```sh
xnode -s<com_port_name> ls
xnode -s<com_port_name> ls /flash/lib/xnode/pop
```

### Put PC file or directroy into XNode
```sh
xnode -s<com_port_name> put my.py /flash/main.py
```
> my.py is the name of the script written on the PC, main.py is the name to be installed on XNode  
>> Automatically runs /flash/main.py if it exists when XNode starts

### Get XNode file to PC
```sh
xnode -s<com_port_name> get /flash/main.py main.py
```

### Delete XNode file or directory
```sh
xnode -s<com_port_name> rm /flash/main.py
```

### Executes the PC's MicroPython script by sequentially passing it to the XNode
```sh
xnode -s<com_port_name> run app.py
```
> Wait for serial output until the script finishes  
>> To force quit in running state, press Ctrl+c

**Additional Options**
   - -in (or default): Does not display the pressed key in the terminal window (Echo off)
   - -i: Display the pressed key in the terminal window (Echo on)
   - -n: Does not wait for serial output, so it appears as if the program has terminated on the PC side.
     - Script continues to run on XNode
     - Used to check data output serially from XNode with other tools (PuTTY, smon, etc.)
TextRefine 1.0.3
The TextRefine class provides a set of methods for text preprocessing and cleaning.
Requires Python: >=3.6

# TextRefine  
**TextRefine** - A Comprehensive Text Cleaning Tool  

`TextRefine` is a powerful Python class designed for text preprocessing and cleaning tasks. It provides a variety of methods to remove unwanted elements from text, making it ideal for use in natural language processing (NLP) and data cleaning projects.

## Features:
- Removes emails, URLs, and phone numbers.
- Cleans text by removing spaces, symbols, and special characters.
- Handles mentions, HTML tags, and non-ASCII characters.
- Supports removing emojis and duplicates in a case-insensitive manner.
- Removes stopwords for better text clarity.

## Usage:
`TextRefine` is easy to use and supports customizable text refinement with minimal setup. Simply initialize the class with your text and apply the desired cleaning methods.

## Installation
pip install TextRefine
aigit 0.1.9
A CLI tool to automatically generate git commit messages using OpenAI GPT-4
Requires Python: >=3.6

# AI-powered Git Helper (AIGIT)

AIGIT is a command-line interface (CLI) tool that uses OpenAI to generate commit messages for your Git repositories. It checks the status of your Git repository, generates a commit message based on the changes, and commits those changes.

## Installation

To install AIGIT, you need Python 3.6+ installed on your system. You have several options:

### Global Installation (Recommended)

Using uv (fastest):
```bash
uv tool install aigit
```

Using pipx (alternative):
```bash
pipx install aigit
```

These methods install AIGIT globally and isolate its dependencies, making it available as the `aig` command anywhere on your system.

### Regular Installation

If you prefer a regular installation:

```bash
pip install aigit
```

Or using uv:
```bash
uv pip install aigit
```

## Configuration

Before using AIGIT, you need to configure your OpenAI API key. Run the following command and enter your API key when prompted:

```bash
aig --config
```

## Usage

```bash
$ aig -h
usage: aig [-h] [--config] [-y]

AI-powered Git Helper

options:
  -h, --help  show this help message and exit
  --config    Configure API Key
  -y, --yes   Auto commit without asking for confirmation
```

To use AIGIT, navigate to your Git repository and run the following command:

```bash
aig
```

AIGIT will check the status of your Git repository, generate a commit message, and ask for your confirmation before committing the changes. If you want to auto commit without confirmation, use the `-y` or `--yes` option:

```bash
aig -y
```

## Development

### Setup Development Environment

1. Clone the repository
2. Install uv if you haven't already: `pip install uv`
3. Install dependencies:
   ```bash
   uv pip install .
   ```

### Making Changes

The project uses `pyproject.toml` for dependency management and build configuration. To add new dependencies:

```bash
uv add <package-name>
```

To remove dependencies:

```bash
uv remove <package-name>
```

### Version Updates

When releasing a new version, update the version number in both:
1. `pyproject.toml`: Update the `version = "x.x.x"` field under `[project]`
2. `aigit/__init__.py`: Update the `__version__ = "x.x.x"` variable

### Building and Publishing

1. Update the version as described above
2. Run the deployment script:
   ```bash
   ./scripts/deploy.sh
   ```

The script will:
- Clean any existing build artifacts
- Build the package with uv
- Upload to PyPI
- Clean up build artifacts if successful
- Keep build artifacts for inspection if upload fails

For manual deployment, you can run these commands individually:
```bash
# Clean artifacts
rm -rf dist/ build/ *.egg-info/

# Build
uv build

# Upload to PyPI
uvx twine upload dist/*
```

## Contributing

Contributions are welcome! Please feel free to submit a pull request.

## License

AIGIT is open-source software licensed under the MIT license.
get-full-year 0.1.0
getfullyear SDK for Python
Requires Python: >=3.8

# get-full-year

An API Wrapper for getfullyear.com.

## Usage:
```python
>>> from get_full_year import FullYear, console
>>> full_year = FullYear()
>>> full_year.year
2025
>>> full_year.sponsored_by
'Pringles: curved potato things in tube'
>>> # the terms of service require we console.log the sponsored_by message
>>> # This package is a special console.log function for this purpose
>>> console.log(full_year.sponsored_by)
Pringles: curved potato things in tube
>>> full_year.year.is_leap()
False
```

## Limitations
- Currently, we don't know the full details of the get-full-year enterprise edition, so our library doesn't support it. 
- While you can do arithmetic operations on the year attribute, they return (int) instead of (Year)

## Roadmap
- Get enterprise information, and support it in this library
- Possibly, `console.log` the sponsored message automatically (to ensure compliance). Possibly not.
dspsim 0.3.9
Simulate Verilog modules using Python bindings for Verilator models.
Requires Python: >=3.12

### Build steps

- read in pyproject.toml tool.dspsim settings.
- run --json-only on all sources with no overrides to get default parameters.
- run --json-only again with overrides to get the final model params.
- generate bindings for all models
- generate include header for project.
- run verilator on all models