semvec/pypi-packages huggingface dataset:
imagen-pa-eval-python-2-mdhcquete 1.0
Evaluacion Python Nivel II

Proyecto - Evaluación. Valor total 100 pts 30%.
Nota: enviar en una carpeta comprimida con nombre y apellido, los códigos fuentes que se
solicitan a con�nuación:
Obje�vo: Evaluar los conocimientos adquiridos en el curso en la realizar de los siguientes códigos:
1. Realizar un programa que cree un directorio con el nombre Examen + Nombre Estudiante, el cual se debe de crear en la unidad C, es decir, en la raíz. A su vez el programa al crear el directorio debe de desplegar el mensaje “Directorio + nombre directorio creado exitosamente y en caso de error o que no se pudo crear desplegará el mensaje “Directorio + nombre estudiante no se pudo crear”. Valor 5 pts.
2. Obtener la úl�ma hora del acceso a la ruta de la Carpeta creada en el punto anterior. Valor 5 pts.
3. Un programa que mediante el uso del subprocess permita mediante la opción de un menú abrir: el Notepad, la calculadora, Word, Excel y Paint. Valor 15 pts.
4. Un programa que valide el ingreso de un nombre y apellido, número telefónico y de correo, si todos están correctos crear un archivo con el nombre “Datos Persona.txt”, este archivo se guardará en la carpeta creada en el punto número uno. Valor 15 pts.
5. En la carpeta creada en el punto uno, crear otra carpeta con el nombre Entorno y dentro de esta realizar un entorno virtual que efectué una pe�ción GET a la url = htps://es.wikipedia.org/w/api.php?ac�on=opensearch&search=Python&limit=5&namespace= 0&format=json Valor 15 pts.
6. Crear una carpeta con el nombre “asset” dentro de la carpeta creada en el punto uno, dentro de la carpeta guardar una imagen con el formato jpg. Luego crear un programa que en la imagen escriba o dibuje su nombre completo con la fecha de creación y luego que lo muestre. El �po de fuente y tamaño de la letra la que guste. Valor 15 pts.
7. Realizar un scrapy de la �enda Universal del apartado “juegos de mesas” Valor 10 pts.
8. De los programas creados anteriormente escoger uno y aplicar el “Docstring” y posterior crear
un paquete instalable y portable. Valor 10 pts.
9. Graficar los datos de la tasa de mortalidad infan�l, publicada en la página oficial del INEC, cuya información la puede obtener del siguiente link: htps://inec.cr/indicadores/tasa-mortalidad- infan�l Valor 10 pts.
hemline 1.1.0
A python library for printing framed text to the terminal.
Requires Python: <4.0,>=3.12

This is yet another python library for creating frames around your terminal
output.

It creates a frame around text, wrapping the text to fit into the frame.

The implementation follows clean code principles such as single responsibility
principle, and dependency injection.


# Install

    pip install hemline

# Documentation

See [jnthnhrr.github.io/python-hemline](https://jnthnhrr.github.io/python-hemline)


# Use

```python3
from hemline import Frame

frame = Frame()
text = "This is some text"
framed = frame.format(text)
```

You will find more detailed examples in the documentation.
marmelade 0.1.0
Use procedural macros in Python
Requires Python: >=3.11


# Macros in Python

**Status**: like really early pre-alpha

Inspired by Rust procedural macros, this package creates a macro system for Python. You can define a macro by writing a function that accepts a string of code and returns another string of code.

Your expanded macro is written to a `__macros__.py` file in the same directory, and automatically imported.

You don't need to add another build step, just run your code as normal. As soon as it runs, your IDE and type checker will start to pass.

> Note: ideally, you should load your module on every save, so that you get better IDE support when using macros. That part's sort of optional, but for my small projects, it's been handy.

## Why would I want this?

Python is a dynamic language, so you can technically do anything... if you don't care about type hinting. But if you're a sane person, then you *must* care about type hinting, and therefore you might care about macros 😛 

I like to think of Python as:
* runtime code can talk to runtime code (normal)
* type checking code can talk to type checking code (normal)
* type checking code can talk to type runtime code (e.g. dataclasses)
* ...but runtime code can't talk to type hinting code

^ macros fill the gap on that last missing step


### Example Use Cases

* If you have a decorator that's impossible to fit with type hints (python generics are nowhere near as powerful as typescript generics, for example); make it a macro instead!
  * E.g. you want to [Concatenate](https://docs.python.org/3/library/typing.html#typing.Concatenate) a kwarg to a paramspec, but it only supports positional arguments
* If you want to modify the behavior of Python code at runtime
  * E.g. you want to build a system where if/else statements are eager evaluated rather than lazy evaluated
* If you have some auto-generated code and you want to auto-generate some type-safe code on top of it
  * E.g. you want to add extra methods to the OpenAPI spec objects that were previously generated

## Differences from Rust

* Rust puts your code inline, this package puts it in a separate file. So you can't automatically use things from the outer scope unless you specify them in the macro.
* Rust macros deal with syntax trees, but this package lets you parse the code yourself; sometimes the formatting of your python code could be important -- it's up to you whether you parse the AST or just do basic string manipulation.
bitbucket-cloud-cli 0.4.0
Atlassian Bitbucket Cloud CLI
Requires Python: >=3.8

# bb - Bitbucket Cloud CLI

A modern command-line interface for interacting with Bitbucket Cloud.

## Features

- **Pull Request Management**
  - List, create, and review pull requests
  - Smart reviewer selection with CODEOWNERS and default reviewers integration
- Rich terminal UI for PR reviews

- **Configuration**
  - User-defined command aliases
  - TOML-based configuration

## Installation

```bash
pipx install bitbucket-cloud-cli
```

## Quick Start

1. Login to Bitbucket:
```bash
bb auth login
```

2. List your pull requests:
```bash
bb pr list --mine
```

3. Create a new pull request:
```bash
bb pr create
```

4. Review pull requests interactively:
```bash
bb pr review
```

Configuration is stored in `~/.config/bb/config.toml`:

```toml
[auth]
username = "your-username"
app_password = "your-app-password"

# Optional aliases added through `bb alias`
[alias]
prm = "pr list --mine"
prr = "pr list --reviewing"
```

## Dev

```bash
git clone git@github.com/systemsoverload/bb
cd bb
rye sync
rye test
pipx install -e ./ --force
```
transcribe-zh-en-p1 0.1.2
This package is a part of a larger pipeline. This is package (PART:1). A package to convert Video containing spoken Chinese audio and Chinese written text and convert it into spoken English and English written text.
Requires Python: <3.9,>=3.8

# Transcribe-zh-en-p1

# This package is a part of a larger pipeline. This is package (PART:1). A package to convert Video containing spoken Chinese audio and Chinese written text and convert it into spoken English and English written text.
buildbot-netauth 0.1.1
buildbot plugin for integration with NetAuth
Requires Python: >=3.11
Keywords: secure-access, authentication-service, netauth, buildbot

## buildbot-netauth

NetAuth authentication, user info, and avatar plugin for buildbot

### Usage

1. Install the plugin, for example: `pip install buildbot-netauth`

2. In your `buildmaster.cfg`, add:

```py
from buildbot.plugins import util

netauth = util.BuildbotNetAuth(conf=Path("/etc/netauth/config.toml"))

# in your buildmaster config object
c["www"]["auth"] = netauth
c["www"]["avatar_methods"] = [netauth, ...]
```

### Notes

The plugin looks at the following metadata on NetAuth entities:

- entity ID: used as an "email" in the format `entity_id@domain`. `domain` is the base domain of the NetAuth server, but is overridable.
- entity display name or legal name: if set, will be used for the `full_name` buildbot user property in that fallback order
- entity group membership: used for the `groups` buildbot user property and can be used for buildbot authz, for example:

```py
from buildbot.plugins import util

c["www"]["authz"] = util.Authz(
    allowRules=[
        util.AnyEndpointMatcher(role="ops", defaultDeny=False),
        util.AnyControlEndpointMatcher(role="ops"),
    ],
    roleMatchers=[
        util.RolesFromGroups(groupPrefix="build-"),
    ]
)
```
zpz 0.5.3
Python utilities.
Requires Python: >=3.8

Python Utilities
================

This repo collects some small Python utilities that I have created (or collected) in practice,
and organizes them as a package named `zpz`.

These utilities are not "one-off" experiments; they are really useful code.
However, they do not form a coherent set of utilities for a particular application domain.
It's reasonable to consider it to be mainly for the author's personal conveniences.
However, I also refrain from making arbitrary, unnecessary breaking changes.
New releases are made on an as-needed basis.

To install, do

```
pip install zpz
```

There are some optional dependencies for specific modules.
pywordle-cli 0.1.3
A command line based wordle game
Requires Python: >=3.7

# Wordle CLI Game

Play the classic Wordle game directly in your terminal! Guess the secret five letter word within six attempts!

[See how it looks like!](https://github.com/ousmanebarry/wordle-cli/blob/main/game-example.png)

## Features

- **Interactive Gameplay:** Receive immediate feedback on your guesses.
- **Colour Coded Hints:** Letters are highlighted to indicate correct positions and presence in the secret word.
  - Requires a terminal that supports coloured output.
- **Command Support:**
  - `/list`: Display the status of all letters.
  - `/grid`: View your current guesses and their evaluations.
  - `/end`: End the current wordle game.

---

## Installation

### Option 1: Install from PyPI (Recommended)

The easiest way to install and start playing is by using `pip`:

```bash
pip install pywordle-cli
```

Once installed, you can start the game by typing:

```bash
wordle
```

---

### Option 2: Install from Source

If you'd like to install the package yourself, follow these steps:

1. Clone the repository:

   ```bash
   git clone https://github.com/ousmanebarry/wordle-cli.git
   cd wordle-cli
   ```

2. Install the package:

   ```bash
   pip install .
   ```

3. Start the game:

   ```bash
   wordle
   ```

---

## How to Play

1. **Gameplay Instructions:**

   - **Guessing:** Enter a valid five letter word and press Enter.
   - **Feedback:**
     - **Green:** Correct letter in the correct position.
     - **Yellow:** Correct letter in the wrong position.
     - **Red:** Letter not in the secret word.

2. **Commands:**

   - **`/list`:** Display the status of all letters.
   - **`/grid`:** View your current guesses and their evaluations.
   - **`/end`:** End the current wordle game.

3. **Winning the Game:**
   - Guess the secret word within six attempts to win.
   - If you fail to guess correctly after six tries, the secret word will be revealed.

---

## Dependencies

- **Python 3.7 or higher**
- **colorama:** For colored terminal text.
- A terminal that supports ANSI color codes.

---

## License

This project is licensed under the MIT License. See the [LICENSE](https://github.com/ousmanebarry/wordle-cli/blob/main/LICENSE) file for details.

---

## Acknowledgements

Inspired by the original [Wordle](https://www.nytimes.com/games/wordle/index.html) game.

---

Enjoy the game and happy guessing! 🎉