semvec/pypi-packages huggingface dataset:
jadio-publisher 0.0.1
Jadio-compatible extension package
Requires Python: >=3.8

# jadio-publisher

Jadio-compatible extension package that adds the `jpub` CLI command.  
`jpub` provides a professional, npm-style publishing workflow for Jadio-based Python packages.

---

## 📦 What is Jadio Publisher?

`jpub` is a modular CLI extension for the [Jadio framework](https://pypi.org/project/jadio/).  

It gives you a full *semantic versioning*, *build*, *publish*, and *Git integration* experience, designed to mimic modern tools like npm and poetry.

✅ Automate version bumping  
✅ Ensure clean builds  
✅ Enforce one-version-per-publish  
✅ Upload to PyPI with Twine  
✅ One-click "release" flow  
✅ Integrated Git commands

---

## ⚡️ Features

- **jpub init** – Initialize jpubconfig in your project
- **jpub bump** – Interactively bump your version
- **jpub show** – View current and last built versions
- **jpub build** – Clean and build your dist/
- **jpub pypi** – Upload dist/* to PyPI via Twine
- **jpub go** – Full release (bump ➜ build ➜ publish)
- **jpub git** – Git helpers (add, commit, push, pull, status, log, repo)

---

## 🚀 Installation

First, install the Jadio framework itself:

```bash
pip install jadio
```

Then install this package:

```bash
pip install jadio-publisher
```

✅ This will register the `jpub` CLI command.

---

## 💻 Quick Start

### 1️⃣ Initialize once per project
Creates `jadio_config/jpubconfig.json` to track builds.

```bash
jpub init
```

---

### 2️⃣ Bump your version
Prompted to choose a new version:

```bash
jpub bump
```

---

### 3️⃣ Build your package
Cleans old dist/ and ensures version is bumped:

```bash
jpub build
```

---

### 4️⃣ Upload to PyPI
Uploads dist/* to PyPI via Twine:

```bash
jpub pypi
```

---

### ⚡️ Or do it all in one step:

```bash
jpub go
```

This runs:

✅ bump ➜ ✅ build ➜ ✅ pypi

---

## 🔗 Git Helpers

Manage git without leaving your CLI:

```bash
jpub git -add
jpub git -commit "message"
jpub git -push
jpub git -pull
jpub git -status
jpub git -log
jpub git -repo
```

---

## 📂 Project Structure Example

After `jpub init`, you'll have:

```
your-project/
├── src/
│   └── your_package/
│       └── __init__.py
└── jadio_config/
    └── jpubconfig.json
```

✅ jpubconfig.json tracks last built version to prevent duplicate publishes.

---

## 🛠️ Requirements

- Python 3.8+
- [Twine](https://pypi.org/project/twine/) installed (`pip install twine`)
- [Build](https://pypi.org/project/build/) installed (`pip install build`)
- Git installed and initialized in your project

---

## ✅ License

MIT License

---

## 🤝 Contributing

Pull requests and feedback welcome!

---

## ✨ Part of the Jadio Modular CLI System

Jadio is a Node.js-style package manager for Python projects.  

✅ Main Framework: [`jadio`](https://pypi.org/project/jadio/)  
✅ Extension: `jadio-publisher` ➜ adds `jpub` command
kuttyPy 2.0.8
Python package for KuttyPy and KuttyPyPlus AVR trainer
Requires Python: >=3
Keywords: atmega32 trainer data-acquisition

# KuttyPy Interactive Playground [ Microcontroller Training Utility ]

[![Documentation Status](https://readthedocs.org/projects/kuttypy/badge/?version=latest)](https://kuttypy.readthedocs.io/en/latest/?badge=latest)

---
The kuttyPy (/kʊtipʌɪ/) Microcontroller training utility allows live manipulation of the registers in microcontrollers via a connected computer containing its python library.  setReg and getReg function calls act as debugging and monitoring tools, and combined with Python's visualization and analytical utilities, this approach has immense pedagogical potential for beginners to the microcontroller world. 

The kuttyPy hardware is an ATMEGA32 microcontroller development board developed by the [ExpEYES](http://expeyes.in) project, and is currently supported by this software. It contains the kuttyPy firmware, but can also be used to run other programs via its bootloader.

---
## What can I use it for?
+ It's an atmega32 development board with a bootloader supporting the 'arduino' protocol
+ The bootloader also allows real-time manipulation of registers through commmands sent via the serial port.
+ This is done by the associated Python library and companion GUI
    + You can monitor every input
    + Toggle every output
    + Deal with Peripherals such as PWMs and Counters
    + View ADC readings via an analog gauge
    + Scan for sensors connected to the I2C Bus
    + Monitor readings from sensors [TSL2561 luminosity, and MPU6050 IMU supported]
+ Compile code to hex with the avr-gcc compiler
+ Upload hex via the built-in uploader
+ Rapidly prototype and debug educational projects. For example, you can verify ADC input values before handing over control to the uploaded hex file which will likely have very limited debugging capabilities.
+ Learn how registers are the key to microcontroller operation, as opposed to the Arduino ecosystem which prefers obfuscation of these details underneath abstraction layers.

## Monitor I2C Sensors

+ Scan for Sensors
+ Click to monitor via analog gauge
+ List of I2C sensors supported thus far (Minimal data logging. Configuration options via the graphical utility might be incomplete)
  + MPU6050 3 Axis Accelerometer, 3 axis Angular velocity (Gyro)
  + TSL2561 Luminosity measurements
  + BMP280 Pressure and Temperature sensor
  + MCP4725 Single channel DAC
  + PCA9685 PWM controller
  + MLX90614 Passive IR

Programming library and examples : [READ THE DOCS](https://kuttypy.readthedocs.io/en/latest/)
exml 0.3.0.1
A tiny eDSL to generate HTML/SVG/XML-looking strings.
Requires Python: >=3.10

# eXML

A tiny eDSL to generate HTML/SVG/XML-looking strings.

## Example

> See tests for more code and output.

```python
import exml

html = exml.Tag("html")
with html.body().table(width="100%") as t:
    with t.tr(class_="fancy") as row:
        row.td("a")
        row.td("b")
    with t.tr(style={"color": "red"}) as row:
        row.attrs["style"]["width"] = 123
        row.td("x")
        row.td("y")
print(str(html))
```
Passwords-Generator 0.1.0
Password generator library
Requires Python: >=3.6


# passwords_generator

A Python library that generates passwords based on 3 parameters: name, age, and birth date (e.g., dd/mm/yyyy).

<img src="https://skillicons.dev/icons?i=python" />

## Table of contents
- [Overview](#overview)
- [Installation](#installation)
- [Usage](#usage)
- [License](#license)
- [Contact](#contact)

## Overview
The **passwords_generator** is a simple module that, given a full name, age, and birth date, generates password combinations between 6 and 18 characters, using case variations, reversal, and character substitutions (A→4, S→$, E→&, etc).

## Installation

1. **Prerequisites**  
   - Python 3.6 or higher installed.
2. **Clone this repository**  
   ```bash
   git clone https://github.com/lucaspy-stack/passwords_generator.git
   cd passwords_generator
   ```

3. *(Optional)* Create and activate a virtual environment:

   ```bash
   python -m venv venv
   # Windows
   venv\Scripts\activate
   # macOS/Linux
   source venv/bin/activate
   ```

## Usage

There are three main scripts in the project:

1. **Password generator** (`Password_Generator.py`)  
   Runs an interactive prompt with:

   ```bash
   python Read_Passwords.py
   ```

   You will be asked to enter:

   * **Full name** (e.g., “Maria Silva”)
   * **Age** (e.g., “30”)
   * **Birth date** (e.g., “15/08/1994”)

   At the end, a `Pass_Generated.txt` file will be created with all the generated passwords.

2. **Password reader** (`Read_Passwords.py`)  
   To display generated passwords in the terminal:

   ```bash
   python Read_Passwords.py
   ```

3. **Using as a library**  
   In your own Python code, import the functions:

   ```python
   from Password_Generator import pass_generator, save_to_txt

   full_name = "João da Silva"
   age = "25"
   birth_date = "10/05/1999"

   passwords = pass_generator(full_name, age, birth_date)
   save_to_txt(passwords, file_name="Pass_Generated.txt")
   ```

### Example output in the `Pass_Generated.txt` file

```
MariaSilva94
mariasilva94
M4r14$1lv4
... (more combinations)
```

## License

This project has no defined license. Feel free to use and adapt it as you wish.  
*Tip:* if you want to release it publicly, consider using a license like MIT or Apache 2.0.

## Contact

* **Email:** [lucas.workps@gmail.com](mailto:lucas.workps@gmail.com)  
* **GitHub:** [https://github.com/lucaspy-stack](https://github.com/lucaspy-stack)
statseis 0.0.6
Package to statistically analyse seismicity
Requires Python: >=3.8

[![DOI](https://zenodo.org/badge/807570243.svg)](https://doi.org/10.5281/zenodo.14051948)

This module is a work in progress.

This module was made to ensure the work from Azad Khan et al., 2024 [![DOI](https://zenodo.org/badge/807570243.svg)](https://doi.org/10.22541/au.173359504.42353416/v1) is open access and reproducible.

Currently this module contains functions to:
- importing, processing, and standardising earthquake source parameter data
- statistically analyse seismicity (source parameters e.g. time, location, and magnitude)
- selecting mainshocks using Fixed Window and Magnitude-Dependent Window aftershock exclusion methods
- identifying foreshocks using the Background Poisson, Gamma Inter-Event Time, and Empirical Seismicity Rate methods

Many functions require the renaming of earthquake catalog dataframe columns to: ID, MAGNITUDE, DATETIME, LON, LAT, DEPTH.

This module contains methods for a Magnitude-Dependent Window mainshock selection method, as described in Trugman and Ross (2019), and a Fixed Window method as described in Moutote et al. (2021). It also integrates code from van den Ende and Ampuero (2020) for a Gamma Inter-Event Time foreshock identification method, and from Herrmann and Marzocchi (2021) for estimating the magnitude of completeness using the Lilliefors test.

Implementations of functions from this module can be found at: [![DOI](https://zenodo.org/badge/807570243.svg)](https://doi.org/10.5281/zenodo.14055539).
mysqlSaver 0.2.7
This Is MySQL Package That You Can Save DataFrame As Table, Partition, Update , Primarykey And Unique In MySQL
Requires Python: >=3.9

<h1 align="center">
  <img src="https://raw.githubusercontent.com/kasrakhaksar/mysqlsaver/refs/heads/master/mysqlSaver/icon/icon.png" alt="logo" width="32">
  <strong>MySqlSaver</strong>
</h1>
<p align="center">
  Effortlessly save your pandas DataFrames into MySQL with automatic table creation and support for primary keys and partitioning.
  <br><br>
  <a href="https://github.com/kasrakhaksar/mysqlsaver" target="_blank">
    <img src="https://img.shields.io/badge/GitHub-Repo-blue?logo=github" alt="GitHub" />
  </a>
</p>


---

## Installation

```bash
pip install mysqlsaver
```

---

## Connection

Create a connection to your MySQL database:

```python
from mysqlSaver import Connection

conn = Connection.connect(
    host="your_host",
    port="your_port",
    username="your_username",
    password="your_password",
    database="your_database"
)
```

---

## Keys Manager



```python
from mysqlSaver import KeyManager

key_mgr = KeyManager(conn)


key_mgr.add_primary_key('my_table', ['id'])

key_mgr.drop_primary_key('my_table')


key_mgr.add_unique_key('my_table', ['email' , 'name'])

key_mgr.drop_unique_key('my_table', 'unique_email_name')
```


- Create the primarykey or unique fields
- Drop the primarykey or unique fields


### Save a DataFrame

```python
from mysqlSaver import Saver
import pandas as pd

df = pd.DataFrame({...})
saver = Saver(conn)
saver.sql_saver(df, "table_name")
```

This function:
- Creates the table if it does not exist
- Inserts the DataFrame data

### Save with Primary Key

```python
saver.sql_saver_with_primarykey(df, "table_name", primary_key_list=["id"])
```

### Save with Primary Key and Auto-Update

```python
saver.sql_saver_with_primarykey_and_update(df, "table_name", primary_key_list=["id"])
```

This performs UPSERT using the primary key.

### Save with Unique Key (No Duplicate Insertions)

```python
saver.sql_saver_with_unique_key(df, "table_name")
```

### Update Table Based on Primary Key

```python
saver.sql_updater_with_primarykey(df, "table_name", primary_key_list=["id"])
```

---

## Checker and Reader

```python
from mysqlSaver import CheckerAndReceiver

checker = CheckerAndReceiver(conn)
exists = checker.table_exist("table_name")
df = checker.read_table("table_name")
```

---

## Table and Database Creation

```python
from mysqlSaver import Creator

creator = Creator(conn)
creator.database_creator("new_database")
creator.create_table(df, "new_table")
```

---

## Partitioning Tables

```python
from mysqlSaver import Partition

partitioner = Partition(conn)
partitioner.create_partition_table(
    df,
    "partitioned_table",
    range_key="your_date_column",
    primary_key_list=["id"],
    start_year_partition=2020,
    end_year_partition=2025
)
```