semvec/pypi-packages huggingface dataset:
bluesky-python 0.0.2
A small bluesky API Wrapper
Requires Python: >=3.8

# Bluesky-Python
Just a very lightweight wrapper around the Bluesky API


### Installation
`pip install -U bluesky-python`

### Example

```py
from bluesky import BlueskyBasicClient

client = BlueskyBasicClient.from_login_data("example.bsky.social", "1234567890")

client.say("Hello World!")
```
winged-python 0.1.0
Winged-Python is an innovative Domain-Specific Language (DSL) library for efficient HTML writing in Python.

# Winged-Python

![main](https://github.com/micheltlutz/Winged-Python/actions/workflows/python-package.yml/badge.svg?branch=main)
[![codecov](https://codecov.io/gh/micheltlutz/Winged-Python/graph/badge.svg?token=UvaQd65VVD)](https://codecov.io/gh/micheltlutz/Winged-Python)
[![codebeat badge](https://codebeat.co/badges/b0a28fb9-ffba-4214-980f-a4333781f98f)](https://codebeat.co/projects/github-com-micheltlutz-winged-python-main)
[![Reviewed by Hound](https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg)](https://houndci.com)

# =============

Winged-Python is an innovative Domain-Specific Language (DSL) library for efficient HTML writing in Python. Mirroring its Swift counterpart, Winged-Python is based on the DSL concept, focusing on simplification and specificity in HTML generation. Using the Composite design pattern, the library enables developers to construct HTML structures in a logical, organized, and reusable manner.

This library is created to be fully independent, not requiring integration with specific server frameworks or front-end libraries. This offers developers the freedom to use Winged-Python across a variety of projects, from simple static pages to complex web applications, keeping the code clean, readable, and efficient.

## Usage Example


```python

from winged.HTML.div import Div
from winged.HTML.h import H
from winged.HTML.table import Table
from winged.HTML.string import String

divC = Div(("class", "container"))

h = H("1")
h.add(String("Hello World"))
divC.add(h)

table = Table()
table.add_table_headers(["Name", "Age", "Height", "Location"])  # Define headers

table.add_row()
table.add_in_row(String("John"))
table.add_in_row(String("25"))
table.add_in_row(String("1.80"))
table.add_in_row(String("New York"))

table.add_row()
table.add_in_row(String("Maria"))
table.add_in_row(String("23"))
table.add_in_row(String("1.50"))
table.add_in_row(String("New Jersey"))

divC.add(table)

print(divC.generate())
```

## Output

```html
<div class="container">
  <h1>Hello World</h1>
  <table>
    <thead>
      <th>Name</th>
      <th>Age</th>
      <th>Height</th>
      <th>Location</th>
    </thead>
    <tbody>
      <tr>
        <td>John</td>
        <td>25</td>
        <td>1.80</td>
        <td>New York</td>
      </tr>
      <tr>
        <td>Maria</td>
        <td>23</td>
        <td>1.50</td>
        <td>New Jersey</td>
      </tr>
    </tbody>
  </table>
</div>
```

## Contributing

To contribute, it's simple, follow the guidelines below to prepare your development environment

## Create environment

User OS terminal or IDE terminal

### Linux or macOS

```bash
python3 -m venv venv
```

```bash
source venv/bin/activate
```

### Windows

```bash
.\venv\Scripts\activate.bat
```

```bash
.\venv\Scripts\activate.ps1`
```

## Install dependencies

```bash
python3 -m pip install -r requirements.txt
```

## Run tests

```bash
pytest
```


## TODO

- [ ] Make documentation with Sphinx
getownip 0.0.5
Get your own ip address
Requires Python: >=3.5

# getownip - A python script to determine your ip address

Example:

```python
import getownip
print("public IPv4: " + getownip.get(getownip.Public, getownip.IPv4))
print("local IPv6: " + getownip.get(getownip.Local, getownip.IPv6))
```

To retrieve a local ip address, a default route must exist. Otherwise, `None` is returned.

When retrieving a public ip address, a random one of a list of servers is accessed.
Currently, the following list of servers is used:

| service       | IPv4 | IPv6 |
|---------------|------|------|
| getmyip.dev   |  yes |  yes |
| icanhazip.com |  yes |  yes |
| ident.me      |  yes |  yes |
| ipaddress.com |  yes |      |
| ipify.org     |  yes |  yes |
| ipinfo.io     |  yes |  yes |
| ipy.ch        |  yes |      |
| l2.io         |  yes |      |
| meineipv6.de  |  yes |  yes |
| my-ip.io      |  yes |  yes |
| seeip.org     |  yes |  yes |
| tnedi.me      |  yes |  yes |

If one of these services fails to answer, another one will be tried until every service has failed.
In this case, the last occurred exception will be thrown.
UNAV-KRK 0.2
Descarga y plotea monedas de kraken
Requires Python: >=3.6

# Analizador de Criptomonedas
El Analizador de Criptomonedas es una biblioteca de Python diseÃ±ada para descargar y analizar datos de criptomonedas desde la API de Kraken. Ofrece funcionalidades para visualizar la cotizaciÃ³n de criptomonedas y calcular indicadores tÃ©cnicos como el oscilador estocÃ¡stico.

# CaracterÃ­sticas
Descarga de datos histÃ³ricos de pares de criptomonedas desde Kraken.
CÃ¡lculo del oscilador estocÃ¡stico.
GeneraciÃ³n de grÃ¡ficos de velas japonesas.
VisualizaciÃ³n de la evoluciÃ³n del precio y del oscilador estocÃ¡stico.
# Cambios con respecto a la 0.1
Se incluye una funciÃ³n graficador() que contiene el cÃ³digo del programa princpial de tal forma que el usuario solo tenga que llamar a la funciÃ³n e insertar el par de monedas a graficar
# InstalaciÃ³n
Puede instalar el Analizador de Criptomonedas directamente desde PyPI:

### Instalar el paquete 
pip install UNAV-KRK==0.2
# Uso
A continuaciÃ³n, se muestra un ejemplo bÃ¡sico de cÃ³mo utilizar la biblioteca:

### Importar funciÃ³n
from src.analizador_monedas  import graficador

### Llamar a la unficÃ³n graficador()
par_moneda = "XBTEUR"

### Insertar input del par de monedas a graficar
Ingrese el par de monedas a analizar (ejemplo: XBTEUR): ETHUSDT



# Requisitos
Python 3.6 o superior.
Dependencias: krakenex, pandas, matplotlib, mplfinance. Estas se instalarÃ¡n automÃ¡ticamente al instalar este paquete.
# Contribuciones
Las contribuciones son bienvenidas. Si deseas contribuir, por favor:

Haz un fork del repositorio.
Crea una rama para tu caracterÃ­stica.
Haz tus cambios y commit.
Push a tu rama y abre un pull request.
# Licencia
Este proyecto estÃ¡ licenciado bajo la Licencia MIT - vea el archivo LICENSE para mÃ¡s detalles.
griddb 0.0.1
Query power systems data
Requires Python: >=3.8

# griddb

[![PyPI - Version](https://img.shields.io/pypi/v/griddb.svg)](https://pypi.org/project/griddb)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/griddb.svg)](https://pypi.org/project/griddb)

-----

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install griddb
```

## License

`griddb` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
aiconfig-extension-llama-guard 0.0.3
An extension for using LLama Guard with aiconfig
Requires Python: >=3.10

# LLama Guard with AIConfig

LLama Guard is a 7b model released by Meta. This extension allows you to use it with AIConfig.

LLaMA Guard allows you to define your own “safety taxonomy” — custom policies to determine which interactions are safe vs. unsafe between humans (prompts) and AI models (responses). What makes this cool is that it allows you to enforce your own policies _ON TOP_ of the standard guardrails that a model ships with (instead of merely overriding them).

> [!NOTE] This extension also loads the entire model into memory.

## Part 1: Installating, Importing, and using this extension

1. Install this module: run `pip3 install aiconfig_extension_llama_guard` in terminal
2. Add these lines to your code:

```python
from aiconfig_extension_llama_guard import LLamageGuardParser
from aiconfig.registry import ModelParserRegistry
```

3. In code, construct and load the model parser that to from this extension to the registry: `ModelParserRegistry.register_model_parser(LLamageGuard())`. You can read the docstrings under `ModelParserRegistry` class for more info o nwhat this does.
4. Use the `LLamageGuard` model parser however you please. Check out our tutorial to get started ([video walkthrough](https://www.youtube.com/watch?v=XxggqoqIVdg), [Jupyter notebook](https://github.com/lastmile-ai/aiconfig/tree/v1.1.8/cookbooks/LLaMA-Guard)) You can watch our video tutorial or check our Jupyter notebook tuto

## Part 2: Updating & Developing this extension

If you are not developing this extension locally (just using the published extension), feel free to ignore this part

1. Navigate to `extensions/LLama-Guard/python` and run this command: `pip3 install -e .` (this creates a local copy of the python module which is linked to this directory)
2. Edit and test the extension as you please. Feel free to submit a push request on GitHub!
3. After you're done testing, be sure to uninstall the local link to this directory if you ever want to use the published version: `pip3 uninstall aiconfig_extension_llama_guard`
taurus-publisher 1.0.2
Python library using LUA script to send for redis a job for Taurus queue
Requires Python: >=3.6.9

# Python Taurus Queue Publisher

[![Latest Version](https://img.shields.io/github/v/release/not-empty/taurus-publisher-python.svg?style=flat-square)](https://github.com/not-empty/taurus-publisher-python/releases)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)

Python library using LUA script to send for redis a job for Taurus queue

### Installation

[Release 1.0.2](https://github.com/not-empty/taurus-publisher-python/releases/tag/1.0.0) Requires [Python](https://www.python.org/) 3.6.9

The recommended way to install is through [Pip](https://pypi.org/project/pip/).

```sh
pip3 install taurus-publisher
```

### Usage

Publishing

```python
from taurus_publisher.publisher import Publisher
import asyncio

async def test_publish():
    publisher = Publisher()

    data = '{"python":1}'

    job_id = await publisher.add_job(
        queue="python",
        data=data,
        opts={},
        name="process"
    )

    print(f"Job added with ID: {job_id}")

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(test_publish())
    loop.close()
```

### Development

Want to contribute? Great!

The project using a simple code.
Make a change in your file and be careful with your updates!
**Any new code will only be accepted with all validations.**

**Not Empty Foundation - Free codes, full minds**
ncap-vaip-api 0.67.0
A package representing an API implementation of the vAIP ontology
Requires Python: >=3.6

Use the vAIP API to help build up entities based on the vAIP ontologies.

There are a few example files demonstrating use:
- `pattern_example.py`: creates an IdentityStoragePattern and deploys it to an S3 bucket
- `process_example.py`: creates all StorageTemplates and TaskTemplates for a single ProcessTemplate, and deploys the ProcessTemplate to Neptune
- `premade_patterns.py`: a collection of functions that build the Patterns used for most of the ProcessTemplates defined in `api/vaip/process_templates`.


# Cloud9 SQLite Version Upgrade
OwlReady2 currently requires at least sqlite3.41, Cloud9 starts with 3.7.x.
Below are the steps to upgrade to a compatiable version.
```
## Download
curl https://www.sqlite.org/2023/sqlite-autoconf-3420000.tar.gz | tar xzf - 

##Move into the folder
cd sqlite-autoconf-3420000/ && ./configure

make

sudo make install

## list your sqlite locations
whereis sqlite3

## Move out of the install folder
cd ..

#sqlite version paths
sudo cp sqlite-autoconf-3420000/sqlite3 /usr/local/bin/sqlite3
sudo cp sqlite-autoconf-3420000/sqlite3 /opt/c9/bin/sqlite3
sudo cp sqlite-autoconf-3420000/sqlite3.h /usr/include/sqlite3.h

## Define the path to new version
export LD_LIBRARY_PATH="/usr/local/lib"

## Cleanup 
rm -r sqlite-autoconf-3420000 
```

To validate the version of sqlite3 your Python environment is using, run this Python code:
```
import sqlite3
print(sqlite3.sqlite_version)
print(sqlite3.__file__)
```
or in a single line:
```
python -c "import sqlite3; print(sqlite3.sqlite_version); print(sqlite3.__file__)"
```

## To trigger a process e.g. dscovr_mag
python trigger_process.py \
https://ncei.noaa.gov/vaip/template/process/d54a223c-6f6b-4f51-b0f2-8f2ab0ceccab/d54a223c-6f6b-4f51-b0f2-8f2ab0ceccab \
nccf-dev-ingest-trust-us-east-1-560271376700 SWPC/DSCOVR/MAG/mg0/2023/05/ neufie

## To trigger a process e.g. ccor1
python trigger_process.py \
https://ncei.noaa.gov/vaip/template/process/9bbf9afb-cb40-46e3-a9e1-c43b4addac04/9bbf9afb-cb40-46e3-a9e1-c43b4addac04 \
nccf-dev-ingest-trust-us-east-1-560271376700 SWPC/GOES-U/CCOR-1/ccor1-l0b/2023/09/05/ neufie
flask-includes-captcha 0.1.1
A simple, limited (basic) wrap of the popular Captcha library for Flask projects.

# flask-includes-captcha
A simple, limited (basic) wrap of the popular Captcha library for Flask projects.


The extension creates Captchas and corresponding tokens that can
be used for verification.


## Installation

Install this extension with pip:

```shell
$ pip install flask-includes-captcha
```
---
## Usage

Set up your app and  configure a secure Captcha Key:

```python
from flask import Flask

app = Flask(__name__)
app.config['CAPTCHA_KEY'] = "use a secure key" #change this
``` 

Import the Captcha class from this extension and initialize it with your app:

```python
from flask_includes_captcha import FlaskCaptcha

flask_captcha = FlaskCaptcha(app)
```

Create a form that includes a string field for the text that should be compared and a 
hidden field for the web token. Implement a function that validates if the
text matched with the Captcha:  

```python
from flask_wtf import FlaskForm
from wtforms import StringField, HiddenField, SubmitField, ValidationError

class ProtectedForm(FlaskForm):
    captcha_text = StringField("Characters")
    captcha_token = HiddenField()
    submit = SubmitField("Submit")
    
    def validate_captcha_text(self, field):
        if not flask_captcha.verify(self.captcha_text.data, self.captcha_token.data):
            raise ValidationError("Wrong Captcha")
```

Send the Captcha image and the token with the form:

```python
from flask import render_template


@app.route('/captcha', methods=["GET", "POST"])
def captcha():
    form = ProtectedForm()

    if form.validate_on_submit():
        pass  # Start processing the form from here

    captcha = flask_captcha.create()
    form.captcha_token.data = captcha["token"]

    return render_template("form.html", captcha=captcha["image"], form=form)
```
The Captcha must be rendered in the template (./templates/form.html):

```html
<img src="data:image/png;base64,{{ captcha }}" alt="CAPTCHA">

<form action="" method="post">
    {{ form.hidden_tag() }}
    {{ form.captcha_text.label }}
    {{ form.captcha_text() }}
    {{ form.captcha_token }}
    {{ form.submit }}
</form>
```

## Dependencies 

- captcha
- flask
- flask-wtf
- joserfc
text-mods 1.55
This code defines a collection of functions for formatting and modifying text
Requires Python: >=3.6

# Text Formatting Toolkit

text_mods is a Python module for formatting text strings in various ways. It includes functions for removing HTML tags and punctuation, replacing words with synonyms, applying different formatting styles such as bold, italic and colored text. In addition it performs natural language processing tasks such as entity recognition, word frequency counting and text summarization.

## Features

* Text Cleaning: Remove HTML tags, punctuation, and numbers from text.
* Text Formatting: Apply styles like bold, italic, underline, and color.
* NLP Tasks: Perform entity recognition, word frequency counting, and summarization.
* Text Transformation: Replace words with synonyms, translate text, and more.
* Sentiment Analysis: Analyze the sentiment of text.
* Customization: Extensive options for text processing tailored to specific needs.

## Requirements

Make sure you have the following requirements installed before running the code:

* Python 3.6 or higher
* NLTK library: Install NLTK using 'pip install nltk'
* NLTK WordNet database
* gensim library
* googletrans library
* spacy library
* en_core_web_sm package for Spacy

## Installation

* Install Python 3.6 or higher from the official website: [Here] (<https://www.python.org/downloads/>)
* Install the NLTK library by running ```pip install nltk``` in your terminal or command prompt.
* Download the WordNet database by running the following commands in a Python interpreter:

``` Python
import nltk
nltk.download('wordnet')
nltk.download('stopwords')
nltk.download('averaged_perceptron_tagger')
```

* Install gensim using ```pip install gensim```
* Install googletrans using ```pip install googletrans```
* Install spacy using ```pip install spacy```
* Download the en_core_web_sm package for Spacy by running ```python -m spacy download en_core_web_sm```
* Install the gensim, googletrans, and spacy libraries by running ```pip install gensim googletrans spacy```
* Download the en_core_web_sm package for Spacy by running ```python -m spacy download en_core_web_sm```
* Download or clone the code from the Github repository: [Github](<https://github.com/Ilija-nik1/text_mods>)

### Clone

Clone the repository using git

``` bash
git clone https://github.com/Ilija-nik1/text_mods.git
```

## Usage

Here are some examples of how to use the functions in the module

``` Python
from text_mods import remove_html_tags, make_bold, replace_with_first_synonym, make_colored

text = '<h1>Hello, world!</h1>'
text = remove_html_tags(text)
text = make_bold(text)
print(text)  # <b>Hello, world!</b>

text = 'This is a sample sentence.'
text = replace_with_first_synonym(text)
text = make_colored(text, 'red')
print(text)  # <span style="color:red">This is a sampling sentence.</span>
```

For more information on each function, please refer to the docstrings in the code.

## Contributing

If you find any bugs or have suggestions for new features, please open an issue or pull request on the Github repository.

## License

This code is licensed under the MIT License.
plotly-click-show 0.1.1
Streamlit component that allows to get the coordinate and curvename of plotly plot
Requires Python: >=3.7

# plotly_click_show

**plotly_click_show** is a Streamlit component that enables you to capture clicking events on a Plotly plot within a Streamlit app. It provides the coordinates and curve names of the clicked points, allowing for interactive data exploration.

## Installation

```bash
pip install plotly_click_show==0.1.0 (Version)


## Usasges
 
import streamlit as st
from plotly.graph_objects import Figure
from plotly_click_show import plotly_events

# Create a Plotly figure
fig = Figure()

# Add your traces and layout configuration here

# Call the plotly_events function to enable clicking events
clicked_points = plotly_events(fig)

# Access the clicked points, which is a list of dictionaries containing x, y, and name
st.write("Clicked Points:", clicked_points)