semvec/pypi-packages huggingface dataset:
qt-life-framework 0.1.4
QT Life Framework - Your Hacker's Gateway to the Multiverse
Requires Python: >=3.7

# Quantum CLI

quantum-cli/
│
├── setup.py
├── requirements.txt
├── README.md
├── install.sh
├── quantum_cli/
│   ├── __init__.py
│   └── main.py
└── tests/
    └── test_main.py

Quantum CLI is a futuristic, hacker-style command-line interface that simulates interactions with a quantum computer system.

## Installation

You can install Quantum CLI using pip:

```
pip install quantum-cli
```

Alternatively, you can use the provided install script to set up a virtual environment and install Quantum CLI:

```
chmod +x install.sh
./install.sh
```

## Usage

After installation, you can run the Quantum CLI by typing:

```
quantum
```

Follow the on-screen instructions to interact with the Quantum CLI.

## Development

To set up the development environment:

1. Clone the repository:
   ```
   git clone https://github.com/yourusername/quantum-cli.git
   cd quantum-cli
   ```

2. Create and activate a virtual environment:
   ```
   python3 -m venv venv
   source venv/bin/activate
   ```

3. Install the package in editable mode:
   ```
   pip install -e .
   ```

## Building

To build the package:

1. Install build tools:
   ```
   pip install build
   ```

2. Build the package:
   ```
   python -m build
   ```

This will create a `dist` directory with the built distributions.

## Deployment

To deploy the package to PyPI:

1. Install Twine:
   ```
   pip install twine
   ```

2. Upload the package to PyPI:
   ```
   twine upload dist/*
   ```

Note: Make sure you have a PyPI account and have configured your `.pypirc` file.

## License

This project is licensed under the MIT License.
ct-counterfactuals 0.0.4
Models and methods to generate counterfactuals for computed tomography scans
Requires Python: >=3.6

# CT Counterfactuals

The code and models here were used in the Paper [📄 Merlin: A Vision Language Foundation Model for 3D Computed Tomography
](https://arxiv.org/abs/2406.06512).

[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/ieee8023/ct-counterfactuals/blob/main/pleural-effusion.ipynb)

## Classifiers

A 1692 target classifier predicting phenotypes from CT scans
```python
import ct_counterfactuals as ct_cf
model = ct_cf.classifiers.phecode.PheCodeClassifier()
x = torch.ones([1, 1, 224, 224, 174])
out = model(x)
out.shape # [1, 1692]
```

A lung segmentation model from CT slices
```python
import ct_counterfactuals as ct_cf
model = ct_cf.classifiers.lungmask.LungMaskSegmenter()
x = torch.ones([1, 1, 224, 224, 174])
out = model(x)
out.shape # [1, 3, 224, 224, 1]

# Channels
# 0 = No lung
# 1 = Right lung
# 2 = Left lung
```

## Autoencoders

A VQ-GAN autoencoder trained on CT slices
```python
import ct_counterfactuals as ct_cf
ae = ct_cf.ae.VQGAN(weights='2023-12-25T10-26-40_ct2_vqgan256_sddd')
x = torch.ones([1, 1, 224, 224])
out = ae(x)
out.shape # [1, 1, 224, 224]
```

Utility code is provided to encode 3D volumes
```
import ct_counterfactuals as ct_cf
ae = ct_cf.ae.VQGAN(weights='2023-12-25T10-26-40_ct2_vqgan256_sddd')

slice_ae = SliceAEFull(ae, 45, 55) # range specified is where gradients can propigate
x = torch.ones([1, 1, 224, 224, 174])
out = ae(x)
out.shape # [1, 1, 224, 224, 174]
```

## Example CF explainations of the classifier

| Effusion (fluid in lungs) | Splenomegaly (enlarged spleen)|
| ----------- | ----------- |
| <img src="docs/effusion2.gif" width="100%"> |  <img src="docs/Splenomegaly.gif" width="100%"> |
cpfpy 0.0.1
This Python module validates and formats CPF numbers, ensuring they are correct and follow the standard Brazilian format.
Requires Python: >=3.0

# CPFPY

This Python module provides tools for validating and formatting CPF numbers.

## Installation

To install, you can use pip:

```bash
pip install cpfpy
```

## Usage

### Validation

```python
from cpfpy import validate_cpf

cpf = "123.456.789-09"
if validate_cpf(cpf):
    print("Valid CPF!")
else:
    print("Invalid CPF.")
```

### Formatting

```python
from cpfpy import format_cpf

cpf = "12345678909"
formatted_cpf = format_cpf(cpf)
print(formatted_cpf)  # Output: 123.456.789-09
```

## License

[MIT](https://choosealicense.com/licenses/mit/)
blueprint-environments 0.1.2
Set of tools to manage environments
Requires Python: <4.0,>=3.8

# Environments

This README provides an overview of the environment configurations defined in `environments/core.py`.

## Environment Class

The `Environment` class is defined to represent different deployment environments. It has the following attributes:

- `name`: The name of the environment (e.g., "development", "staging", "production")
repotokens 1.0.1
Count number of LLM tokens of source files contained in the repository / folder

# repotokens

repotokens is a Python package for analyzing entire source repositories to count tokens and estimate costs for various LLMs. It can be used both as a command-line tool and as an importable Python library.

## Features

- Analyzes entire repositories to count tokens on common source file types.
- Opinionated about excluding those filetypes / utilities that are unlikely to be useful for LLM reasoning on top of the repository.
- Estimates costs of for different LLMs based on token count
- Respects .gitignore files and common ignore patterns
- Can be used as both a Python library and a command-line tool


## Installation

You can install repotokens using pip:

```bash
pip install repotokens
```

## Usage as a Python Library

You can use repotokens in your Python scripts by importing it as follows:

```python
from repotokens import analyze_directory, calculate_costs, MODELS
```

### Analyzing a Directory

To analyze a directory and get token counts:

```python
results = analyze_directory("/path/to/your/repo")
print(f"Total tokens: {results['total_tokens']}")
print(f"Processed files: {results['processed_files']}")

# Print token counts for each file
for file, tokens in results['file_tokens'].items():
    print(f"{file}: {tokens} tokens")
```

### Calculating Costs for a Specific Model

To calculate costs for a specific model:

```python
model = "gpt-4o"
total_tokens = results['total_tokens']
costs = calculate_costs(total_tokens, model)

print(f"Costs for {model}:")
print(f"Input cost: ${costs['input_cost']:.2f}")
print(f"Output cost: ${costs['output_cost']:.2f}")
```

### Getting Information for All Models

You can access information about all available models:

```python
for model, prices in MODELS.items():
    print(f"{model}:")
    print(f"  Input price: ${prices['input_price']} per 1M tokens")
    print(f"  Output price: ${prices['output_price']} per 1M tokens")
```

## Command-Line Usage

repotokens can also be used as a command-line tool:

### Analyze Current Directory

```bash
repotokens
```

### Analyze a Specific Directory

```bash
repotokens /path/to/your/repo
```

### Analyze a Directory and Show Costs for a Specific Model

```bash
repotokens /path/to/your/repo --model gpt-4o-mini
```

### Show Version

```bash
repotokens --version
```
took 0.0.12
CLI tool to track time spent on tasks.
Requires Python: >=3.6

# Took

Took is a command-line tool for time tracking and task management, designed to help you efficiently manage and monitor the time spent on various tasks and projects. With Took, you can start, pause, and resume tasks, view detailed reports, and manage your time more effectively.  It's simple to set up and integrates seamlessly with your workflow.

## Features

- **Track Time:** Start tracking time for specific tasks, allowing you to keep a detailed log of how much time you spend on each task.
- **Pause and Resume:** Easily pause and resume tasks, ensuring that your time logs are accurate and reflect actual working hours.
- **Task Creation:** Automatically create tasks when starting time tracking for a task that doesn't exist.
- **Task Status:** View the status of all tasks, including time spent and the last time they were updated.
- **Task Logs:** Log time spent on tasks and store daily logs.
- **Daily Reports:** Generate reports to visualize the time spent on tasks over a specified number of days.
- **Persistent Storage:** All tasks and time logs are stored in a JSON file within the project directory, ensuring that your data is persistent across sessions and can be committed to the VCS.

## Installation

You can install Took using pip:

```bash
pip install took
```

## Usage

### Initialize a New Project

Before using Took, initialize it in your project directory:

```bash
$ took init
```

This command creates a `.took` directory and initializes the `took.json` file in the current directory.

### Start Tracking Time

To start tracking time for a task:

```bash
$ took start -t <task_name>
```

If the task doesn't already exist, it will be created automatically.

### Pause Tracking Time

To pause the currently active task:

```bash
$ took pause
```

### Resume a Paused Task

To resume tracking the paused task:

```bash
$ took start
```

This command will resume the most recently paused task.

### View Task Status

To view the current status of all tracked tasks, including time spent and last updated time:

```bash
$ took status
```

### View All Tracked Tasks

To see all tasks that are currently being tracked:

```bash
$ took show-all
```

### View Task Logs

To view the time logged per day for a specific task:

```bash
$ took log -t <task_name>
```

### Generate Daily Reports

To generate a report that shows the time spent on each task over the last `n` days:

```bash
$ took report -d {n_days}

╭───────────────────────╮
│ Reports (Last 3 Days) │
╰───────────────────────╯
2024-09-01
Task A: █████████████████████ 51m-7s
Task B: ███ 8m-53s
Task C: ████ 11m-7s

2024-09-02
Task A: ████████████████████ 11h-57m-47s
Task B: ██ 1h-47m-12s
Task C: ██████ 4h-10m-8s

2024-09-03
Task A: ██████ 27m-21s
Task B: █████ 20m-55s
Task C: ██████████████████ 1h-12m-47s

```

## Contributing

We welcome contributions to Took! If you have suggestions, improvements, or bug fixes, please open an issue or submit a pull request on GitHub.

## License

Took is licensed under the MIT License. See [LICENSE](LICENSE) for more details.
greptimedb-sqlalchemy 0.1.7
SQLAlchemy support for GreptimeDB
Requires Python: >=3.9

# greptimedb-sqlalchemy

![PyPI - Version](https://img.shields.io/pypi/v/greptimedb-sqlalchemy)

SQLAlchemy and Superset connector for
[GreptimeDB](https://github.com/greptimeteam/greptimedb).

This is a work in progress.

## Superset

If you are using docker to run superset, add this library to
`docker/requirements-local.txt`

```bash
echo "greptimedb-sqlalchemy" > docker/requirements-local.txt
```

Start superset using `docker compose -f docker-compose-non-dev.yml up` you will
be able to add GreptimeDB as a database.
recuero 1.1
Una biblioteca para consultar cursos de hack4u

# Hack4U Academy Courses Library

Una biblioteca Python para consultar cursos de la academia Hack4U.

## Cursos disponibles:

- Introducción a Linux [15 horas]
- Personalización de Linux [3 horas]
- Introducción al Hacking [53 horas]

## Instalación 

Instala el paquete usando `pip3`:

```python3
pip3 install hack4u
```

## Uso básico

### Listar todos los cursos

```python
from hack4u import list_courses

for course in list_courses():
    print(course)
```

### Obtener un curso por nombre

```python
from hack4u import search_course

course = get_course_by_name("Introducción a Linux")
print(course)
```

### Calcular duración total de los cursos

```python
from hack4u.utils import total_duration

print(f"Duración total: {total_duration()} horas")
```