semvec/pypi-packages huggingface dataset:
THack4u 0.1.0
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 entorno en Linux [3 horas]
- Introducción al Hacking [53 horas]
- Python Ofensivo [35 horas]

## Instalación

Instala el paquete usando `pip3`:

```python3
pip3 install hack4u
```

## Uso básico

### Listar todos los cursos

```python
from hack4u import listCourses

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

### Obtener un curso por nombre

```python
from hack4u import getCourseByName

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

### Calcular duración total de los cursos
```python
from hack4u import totalDuration

print(f"Duración total: {totalDuration()} horas")
```
gsheet-api-handler 0.1.3
Paquete para la autenticación y lectura de datos desde Google Sheets con manejo de errores integrado pensado para Google Colab.
Requires Python: >=3.6

# Google sheet API handler

**gsheet_api_handler** es un paquete de Python diseÃ±ado para facilitar la autenticaciÃ³n y la lectura de datos desde Google Sheets. Incluye un mecanismo robusto de manejo de errores con reintentos exponenciales para asegurar la confiabilidad en la recuperaciÃ³n de datos pensando para el uso en el entorno de google colab.

## CaracterÃ­sticas

- **AutenticaciÃ³n en Google Sheets**: Utiliza las credenciales de Google para autenticar y acceder a hojas de cÃ¡lculo.
- **Lectura de Datos**: Extrae los datos de una hoja especÃ­fica de Google Sheets en formato de lista.
- **Manejo de Errores**: Implementa un sistema de reintentos exponenciales para manejar errores temporales de manera efectiva cuando la cantidad de requests realizadas supera la cuota.

## InstalaciÃ³n

Para instalar **gsheet_api_handler**, puedes utilizar `pip`. Abre una terminal y ejecuta el siguiente comando:

```bash
pip install gsheet_api_handler
```
## Uso

```python
from gsheet_api_handler import google_sheet_reader, backoff_retry

# URL del Google Sheet y nombre de la hoja
url = "https://docs.google.com/spreadsheets/d/your_spreadsheet_id"
sheet_name = "Sheet1"

sheet_data = backoff_retry(lambda: google_sheet_reader(url, sheet_name))
print(sheet_data)
```
CleanNumbersArmon 0.0.1
A small example package
Requires Python: >=3.7

__CLEAN NUMBER PACKAGE__

# CleanNumber Package

## Overview

The `clean_number` package provides a single function designed to normalize and clean numeric inputs. This function takes various formats of numbers, converts them into a standardized floating-point representation, and returns them as a string with 14-point precision.

## Function: `clean_number`

The `clean_number` function processes a range of inputs, from scientific notation to unconventional formats, and produces a cleaned, standardized output. Below is a table of inputs and their corresponding outputs before being converted to 14-point precision.
As you can see, numeric inputs can be processed and non-numeric inputs are converted into N/A for easy data processing.

### Input and Output Table
_____________________________________________________________
| Input                  | Output                           |
|------------------------|----------------------------------|
| `7E01`                 | `70`                             |
| `6.05E02`              | `605.0`                          |
| `3.05E-02`             | `0.0305`                         |
| `3E-02`                | `0.03`                           |
| `7E12`                 | `7000000000000`                  |
| `3.05E-5`              | `3.05e-05`                       |
| `3.05X10^-5`           | `3.05e-05`                       |
| `3E-12`                | `3e-12`                          |
| `0.01`                 | `0.01`                           |
| `0.01020`              | `0.0102`                         |
| `10`                   | `10`                             |
| `05`                   | `5`                              |
| `2**(-31)`             | `4.656612873077393e-10`          |
| `231.10`               | `231.1`                          |
| `Note 3.`              | `N/A`                            |
| `MCC`                  | `N/A`                            |
| `see below`            | `N/A`                            |
| `*`                    | `N/A`                            |
| `N/A`                  | `N/A`                            |
| `0.1yd/0.01nm`         | `N/A`                            |
| `(20/360)/16384`       | `10.0`                           |
| `2**(-07)`             | `3.3908420138888887e-06`         |
| `NOTE5`                | `N/A`                            |
| `1 foot`               | `1`                              |
-------------------------------------------------------------

### Precision and Output

After processing the input, the output values are converted to a floating-point representation with 14-point precision and returned as a string. This ensures consistency and accuracy in numerical representation, making it suitable for precise calculations and data presentation.

## Installation

To install the `clean_number` package, use the following command:

```bash
pip install clean_number
bedfinder 0.0.1
A Python package to automate the classification of glacially derived bedforms.
Requires Python: >=3.9

<p align="center">
  <img width="450" src="https://github.com/elliesch/bedfinder/blob/main/figs/logo.png"/>
</p>

# `bedfinder`: A Python package for the Automatic Detection of Glacially-derived Bedforms

The `bedfinder` workflow automates the detection of glacially-derived bedforms for landforms identified from the Topographic Position Index (TPI) tool using machine learning. Users can pick one of three trained ensemble models (Random Forest, XGBoost, or the ensemble average of both) to detect bedforms from positive relief landforms, and choose to output detections as bedform probabilities or as binarized predictions. `bedfinder` also includes a routine for running a scientifically-driven prefiltering routine on TPI data to prepare it for use with machine learning models.

`bedfinder` can be used directly in Python, or as part of our ArcGIS pipeline, which incorporated with TPI, allows for the detection of bedforms directly from DEMs. Check out the notebooks available here or on CryoCloud for examples of how to apply `bedfinder` to your data, or follow the quickstart guide below.

# Installation

`bedfinder` can be installed using `pip`:

```bash
pip install bedfinder
```

Note that the `bedfinder` package requires Python 3.9 or later.

# Quickstart

Import the main interface:

```python
from bedfinder import ClassifyBedforms
```

Automatically detect bedforms from a TPI output CSV:

```python
# Instantiate bedfinder
landforms = ClassifyBedforms(
  input_csv='~/path/to/your/TPI/CSV',  # path to your input TPI csv
  model='ensemble_average',            # machine learning model choice
  threshold=0.45,                      # probability threshold
  probability=False                    # output as a binary prediction
)

# Define the predicted landforms
predicted_bedforms = landforms.predicted_bedforms
```

# References & Attribution
The code is under development and will be described in a paper and Jupyter Book.
If you make use of this code in your research, please cite:
```
LaTeX citations to go here.
```

If you make use of the training data in your research, please cite:
```
@misc{mckenzie2022_dataset,
 author={Marion A {McKenzie} and Lauren M {Simkins} and Sarah M {Principato}},
 title={{Streamlined subglacial bedforms across the deglaciated Northern Hemisphere}},
 year={2022},
 doi={10.1594/PANGAEA.939999},
 url={https://doi.org/10.1594/PANGAEA.939999},
 type={data set},
 publisher={PANGAEA}
}
```

If you make use of the Wisconsin Bay Lobe data in your research, please cite:

[![DOI](https://zenodo.org/badge/768265366.svg)](https://zenodo.org/doi/10.5281/zenodo.11660146)
```
@misc{wiscbaylobe_dataset,
  author       = {Ellianna {Abrahams} and Marion A {McKenzie},
  title        = {bedfinder: A Python package for the Automatic Detection of Glacially-Derived Bedforms},
  year         = {2024},
  doi          = {10.5281/zenodo.11660146},
  url          = {https://zenodo.org/doi/10.5281/zenodo.11660146},
  note         = {Pre-release}
}
```
mizuku 1.1.2
A command-line interface tool to make a professional HTML website from MIML files.
Requires Python: >=3.9

# Mizuku = 水区 = Water District

This is a Python package that provides the CLI script `mizu`, meaning "water".

It converts .mizu files to .html files.

## Installation

    pip install mizuku

## Usage

    mizu

## Documentation

`mizu` is designed to produce output for any number of domain names.

This is useful for A/B testing domain names for your product or website.

The domains are listed one per line in the DOMAINS file.

---

Running `mizu` will look for all .mizu files in the current directory, and convert them to .html files.

So, for example, `Resume.mizu` will be converted to `./example.com/Resume.html`.

If a corresponding CSS file is present (e.g. Resume.css), it's contents will be automatically loaded into the resulting HTML.

---

To wrap some text in `<strong>` tags:

    Look at some *strong text here*; voila!

---

To link to a URL:

    {Text Here}.
    {Text Here|https://example.com}.
    {Text Here|some_file.html}.

The first one will automatically link to `Text_Here.html`.

---

To include an image:

    At any location in a paragraph, just do this: [FileNameGoesHere.png].

Only PNG format is supported and the `.png` extension must be provided.

---

To wrap some text in a `<div>` use the following format:

    [Any text here]
    [center: Any text here]

In the first case, the class of the div will be "Any", and you can style it in the related CSS file.

In the second case, the class of the div will be "center" and the text "center" will not be rendered.

---

To include another mizu file:

    <filename.mizu>

---

To wrap some text in a paragraph tag:

    Here is some text.

    Make sure this text is surrounded by two newlines, before and after, and it
    will get surrounded by P tags.

    Here is some more text.

---

HTML is parsed normally and as expected:

    Some left-aligned text.

    <center>
        Some centered aligned text.
    </center>

---

Bullet points are supported:

    - This is rendered as a bullet point. Make sure to include a space between
      this and the next bullet point, otherwise they're considered the same
      paragraph.

    - Here is the second bullet point!
tilakone 0.1.0
Super simple state machine
Requires Python: <4.0,>=3.11

# Tilakone

Super simple state machine

```PYTHON
from tilakone import StateChart, StateMachine
from typing import Literal

States = Literal["ON", "OFF"]
Events = Literal["toggle", "turn_off"]

state_chart = StateChart[States, Events]({
    "OFF": {
        "initial": True,
        "on": {
            "toggle": "ON"
        }
    },
    "ON": {
        "initial": False,
        "on": {
            "toggle": "OFF",
            "turn_off": "OFF"
        }
    }
})

machine = StateMachine(state_chart)
assert machine.current_state == "OFF"

transitioned = machine.send("toggle")
assert transitioned == True
assert machine.current_state == "ON"

transitioned = machine.send("turn_off")
assert transitioned == True
assert machine.current_state == "OFF"

# Irrelevant events are ignored
transitioned = machine.send("turn_off")
assert transitioned == False
assert machine.current_state == "OFF"

```
wicker 0.0.16
An open source framework for Machine Learning dataset storage and serving
Requires Python: >=3.6

# Wicker

Wicker is an open source framework for Machine Learning dataset storage and serving developed at Woven Planet L5.

# Usage

Refer to the [Wicker documentation's Getting Started page](https://woven-planet.github.io/wicker/getstarted.html) for more information.

# Development

To develop on Wicker to contribute, set up your local environment as follows:

1. Create a new virtual environment
2. Do a `pip install -r dev-requirements.txt` to install the development dependencies
3. Run `make test` to run all unit tests
4. Run `make lint-fix` to fix all lints and `make lint` to check for any lints that must be fixed manually
5. Run `make type-check` to check for type errors

To contribute a new plugin to have Wicker be compatible with other technologies (e.g. Kubernetes, Ray, AWS batch etc):

1. Add your plugin into the `wicker.plugins` module as an appropriately named module
2. If your new plugin requires new external dependencies:
    1. Add a new extra-requires entry to `setup.cfg`
    2. Update `dev-requirements.txt` with any necessary dependencies to run your module in unit tests
3. Write a unit test in `tests/` to test your module
mimetypeplus 1.0.0.0
A powerful Python module for intuitive MIME type management, providing utilities for identifying, creating, and manipulating MIME types in various contexts.
Requires Python: >=3.7
Keywords: MIME, MIME type, content, content type, file, extension, media, type, HTTP, HTML, web, development, content negotiation, file management, internet, utilities


# `mimetypeplus`

> A simple python module focused on easy MIME type manipulation and detection.

[Documentation](https://MarkusHammer.github.io/mimetypeplus-python)

## Setup

This module can be installed using:

```bash
pip install mimetypeplus
```

## Usage

This module is intended to be used only as a module, and can be imported after installing using the traditional process:

```python
from mimetypeplus import MimeType
```

### Create a MIME Type Object

```python
mime = MimeType("application/json")
```

### Identify MIME Types

Quickly determine the MIME type of content from various sources:

```python
# Identify MIME type from a file path
mime = MimeType.from_path("data.json")
mime = MimeType.from_path(__file__)

# Identify MIME type from a URI
mime = MimeType.from_uri("https://example.com/api/data")
```

### Facet Manipulation

```python
# Check if the MIME type is experimental
if mime.experimental_facet:
    print("This is an experimental MIME type.")

# Set a vendor-specific facet
mime.facet = "vnd"
```

### Quickly Find File Extensions

```python
extension = mime.to_extention()
print(f"The file extension for this MIME type is '{extension}'")
```

### And More

There are a handfull of other ease of use features that this module provides, feel free to reference the [documentation](https://MarkusHammer.github.io/mimetypeplus-python) for more information.

## Licence

This is licensed under the Mozilla Public License 2.0 (MPL 2.0) Licence. See the Licence file in this repository for more information.

## Contribute

Contributions are always welcome!
Use the [github repository](https://github.com/MarkusHammer/mimetypeplus-python) to report issues and contribute to this project.

## Credits

While not required, feel free to credit "Markus Hammer" (or just "Markus") if you find this code or script useful for whatever you may be doing with it.

# Security Policy

While the python source code will be actively maintained, any binary files (if at all provided) are in no way supported.
These are provided as a courtesy and are not intended to be the main usage of this software.
Please keep this in mind when choosing how you wish to use this software.

## Supported Versions

| Version     | Supported |
| ----------- | --------- |
| 1.0.0.0 >= | ✅        |
| 1.0.0.0 <  | ❌        |

## Reporting a Vulnerability

Please report any issues to the email 107761433+MarkusHammer(THEN THE @ SYMBOL HERE)users.noreply.github.com
gpt4all 2.8.2
Python bindings for GPT4All
Requires Python: >=3.8

# Python GPT4All

This package contains a set of Python bindings around the `llmodel` C-API.

Package on PyPI: https://pypi.org/project/gpt4all/

## Documentation
https://docs.gpt4all.io/gpt4all_python.html

## Installation

The easiest way to install the Python bindings for GPT4All is to use pip:

```
pip install gpt4all
```

This will download the latest version of the `gpt4all` package from PyPI.

## Local Build

As an alternative to downloading via pip, you may build the Python bindings from source.

### Prerequisites

You will need a compiler. On Windows, you should install Visual Studio with the C++ Development components. On macOS, you will need the full version of Xcode&mdash;Xcode Command Line Tools lacks certain required tools. On Linux, you will need a GCC or Clang toolchain with C++ support.

On Windows and Linux, building GPT4All with full GPU support requires the [Vulkan SDK](https://vulkan.lunarg.com/sdk/home) and the latest [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads).

### Building the python bindings

1. Clone GPT4All and change directory:
```
git clone --recurse-submodules https://github.com/nomic-ai/gpt4all.git
cd gpt4all/gpt4all-backend
```

2. Build the backend.

If you are using Windows and have Visual Studio installed:
```
cmake -B build
cmake --build build --parallel --config RelWithDebInfo
```

For all other platforms:
```
cmake -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo
cmake --build build --parallel
```

`RelWithDebInfo` is a good default, but you can also use `Release` or `Debug` depending on the situation.

2. Install the Python package:
```
cd ../gpt4all-bindings/python
pip install -e .
```

## Usage

Test it out! In a Python script or console:

```python
from gpt4all import GPT4All
model = GPT4All("orca-mini-3b-gguf2-q4_0.gguf")
output = model.generate("The capital of France is ", max_tokens=3)
print(output)
```


GPU Usage
```python
from gpt4all import GPT4All
model = GPT4All("orca-mini-3b-gguf2-q4_0.gguf", device='gpu') # device='amd', device='intel'
output = model.generate("The capital of France is ", max_tokens=3)
print(output)
```

## Troubleshooting a Local Build
- If you're on Windows and have compiled with a MinGW toolchain, you might run into an error like:
  ```
  FileNotFoundError: Could not find module '<...>\gpt4all-bindings\python\gpt4all\llmodel_DO_NOT_MODIFY\build\libllmodel.dll'
  (or one of its dependencies). Try using the full path with constructor syntax.
  ```
  The key phrase in this case is _"or one of its dependencies"_. The Python interpreter you're using
  probably doesn't see the MinGW runtime dependencies. At the moment, the following three are required:
  `libgcc_s_seh-1.dll`, `libstdc++-6.dll` and `libwinpthread-1.dll`. You should copy them from MinGW
  into a folder where Python will see them, preferably next to `libllmodel.dll`.

- Note regarding the Microsoft toolchain: Compiling with MSVC is possible, but not the official way to
  go about it at the moment. MSVC doesn't produce DLLs with a `lib` prefix, which the bindings expect.
  You'd have to amend that yourself.
recorder-viz 0.5.6
Utilities for processing Recorder traces
Requires Python: >=2.7

recorder-viz
=============

This is a python package which contains tools for processing [Recorder](https://github.com/uiuc-hpc/Recorder) traces.

Installation and Visualization
-------------

`recorder-viz` relies on Recorder and a few python libraries to run.
Please see the document [here](https://recorder.readthedocs.io/latest/postprocessing.html#post-processing-and-visualization).

Below are some example graphs generated from the [FLASH](http://flash.uchicago.edu) traces.
![example graphs](https://raw.githubusercontent.com/wangvsa/recorder-viz/main/tests/showoff.jpg)


Advanced Usages
-------------

The `RecorderReader` class contains all infomration about the Recorder traces.

```python
class RecorderReader:
    self.GM: instance of GlobalMetadata
    self.LMs: list of LocalMetadata objects, one for each rank
    self.records: self.records[i] is a list of Record objects of rank i.
```

`GlobalMetadta`, `LocalMetadata` and `Record` are three Python wrappers of C structures. 

```python
class LocalMetadata(Structure):
    self.total_records: int
    self.num_files: int
    self.filemap: set()
    self.function_count: []


class RecorderMetadata(Structure):
    _fields_ = [
            ("total_ranks", c_int),
            ("start_ts", c_double),
            ("time_resolution", c_double),
            ("ts_buffer_elements", c_int),
            ("ts_compression_algo", c_int),
    ]

class Record(Structure):
    _fields_ = [
            ("tstart", c_double),
            ("tend", c_double),
            ("level", c_ubyte),
            ("func_id", c_ubyte),
            ("tid", c_int),
            ("arg_count", c_ubyte),
            ("args", POINTER(c_char_p)),
    ]
```


Here's an example on how to use the provided classes.

```python
from recorder_viz import RecorderReader

reader = RecorderReader("path/to/Recorder-traces-folder")

for rank in range(reader.GM.total_ranks):
    LM = reader.LMs[rank]
    print("Rank: %d, Number of trace records: %d" %(rank, LM.total_records))
```
spacy-chunks 0.0.2
An easy way to chunk spacy docs.
Requires Python: >=3.7

# spaCy Chunks

spaCy Chunks is a custom pipeline component for spaCy that allows you to generate overlapping chunks of sentences or tokens from a document. This component is useful for various NLP tasks that require processing text in smaller, potentially overlapping segments.

## Features

- Chunk by sentences or tokens
- Configurable chunk size
- Adjustable overlap between chunks
- Option to truncate incomplete chunks

## Installation

To use spaCy Chunks, you need to have spaCy installed. You can install spaCy using pip:

```bash
pip install spacy
pip install spacy_chunks
```

Download a spaCy model:

```bash
python -m spacy download en_core_web_sm
```

## Usage

Here's how to use the spaCy Chunks component:

```python
import spacy

# Load a spaCy model
nlp = spacy.load("en_core_web_sm")

# Add the chunking component to the pipeline
nlp.add_pipe("chunking", last=True, config={
    "chunking_method": "sentence",
    "chunk_size": 2,
    "overlap": 1,
    "truncate": True
})

# Process a text
text = "This is the first sentence. This is the second one. And here's the third. The fourth is here. And a fifth."
doc = nlp(text)

# Print the chunks
print("Chunks:")
for i, chunk in enumerate(doc._.chunks, 1):
    print(f"Chunk {i}: {[sent.text for sent in chunk]}")
```

Output:
```
Chunks:
Chunk 1: ['This is the first sentence.', 'This is the second one.']
Chunk 2: ['This is the second one.', "And here's the third."]
Chunk 3: ["And here's the third.", 'The fourth is here.']
Chunk 4: ['The fourth is here.', 'And a fifth.']
```

## Configuration

When adding the chunking component to your pipeline, you can configure the following parameters:

- `chunking_method`: "sentence" or "token" (default: "sentence")
- `chunk_size`: Number of sentences or tokens per chunk (default: 3)
- `overlap`: Number of overlapping sentences or tokens between chunks (default: 0)
- `truncate`: Whether to remove incomplete chunks at the end (default: True)

## Changing Configuration Dynamically

You can change the configuration of the chunking component dynamically:

```python
# Change chunk size
nlp.get_pipe("chunking").chunk_size = 3

# Disable truncation
nlp.get_pipe("chunking").truncate = False

# Process the text again with new settings
doc = nlp(text)
```

## Contributing

Contributions to spaCy Chunks are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License.