semvec/pypi-packages huggingface dataset:
mklib-web 0.0.1
web ui for mklib
Requires Python: >=3.12

# mklib web

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

-----

**Table of Contents**

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

## Installation

```console
pip install mklib-web
```

## License

`mklib-web` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
wonder-diffusion-sdk 0.0.7.1.dev0
Python SDK for common Wonder diffusion models


    Version 0.0.7:
      - AutoencoderTiny model added as an optimization.

    Version 0.0.6:
      - !! Scheduler Config added. Model config scheduler parameter changed. THIS IS A BREAKING CHANGE.
      - Refactor for better controlnet and lora usage.

    Version 0.0.5:
      - ControlNet added.
      - Lora usage added.

    Version 0.0.3:
      - Lightning model added.
      - **kwargs** for schedulers added.
net-genconfig 2.2.3.0
Network device configuration generator

net-genconfig
=============

This package generates configurations for network devices based on three
sources of information:

* roles -- these Jinja2 templates form the basis of an output
  configuration file and exist for each platform and device role (e.g.
  IOS as distribution router; IOS as core router, NX-OS as core router,
  NX-OS as row switch)

* include -- Jinja2 includes (some to be included 'as is' [.j2] and
  some with macros that can be called [.j2m]); these are included by
  the role templates and by each other

* inventory -- this is a big database of device details (including the role for
  a particular device) and associated information, such as VLANs, subnets,
  interfaces, etc.
resume-extractor-ai 0.1
A package to parse resumes and extract structured data using OpenAI API
Requires Python: >=3.6

# Resume Parser AI

🎉 Welcome to Resume Parser AI - your go-to package for parsing resumes and extracting structured data using the OpenAI API! 🎉

With this package, you can easily extract personal information, skills, work experience, education, and more from resumes in PDF and DOCX formats.

## Installation

You can install Resume Parser AI using pip:

```bash
pip install resume-parser-ai
```

## Usage
To parse a resume and extract data, use the parse function:

```bash
from resume_parser import ResumeParser

api_key = "your_openai_api_key"
model = "gpt-4"

parser = ResumeParser(api_key=api_key, model=model)
resume_data = parser.parse("path/to/resume.pdf")

print(resume_data)
```

## Default JSON Structure
The default JSON structure includes the following sections and fields:

```bash
{
    "personal_information": {
        "first_name": "",
        "last_name": "",
        "phone_number": "",
        "email_address": "",
        "linkedin_url": "",
        "website_url": "",
        "headline": ""
    },
    "skill": {
        "category": "",
        "skill_values": []
    },
    "work_experience": [{
        "company_name": "",
        "job_title": "",
        "city": "",
        "country": "",
        "from_date": "",
        "to_date": "",
        "description": ""
    }],
    "education": [{
        "institution_name": "",
        "field_of_study": "",
        "degree": "",
        "grade": "",
        "city": "",
        "country": "",
        "from_date": "",
        "to_date": "",
        "description": ""
    }],
    "certifications": [{
        "certification_name": "",
        "issuer": "",
        "certification_date": "",
        "certification_expiry_date": "",
        "certification_url": "",
        "description": ""
    }],
    "summary": {
        "profile": ""
    },
    "achievements": {
        "achievements": ""
    },
    "projects": [{
        "title": "",
        "project_role": "",
        "city": "",
        "country": "",
        "from_date": "",
        "to_date": "",
        "description": ""
    }]
}
```
## Links
If you want to build and analyze resumes without writing any code, check out our website [ResumeUp.ai](https://resumeup.ai). You can use our platform to generate resumes with AI and get detailed analysis of your resumes.

## Contributing
If you have any ideas or suggestions for improving this package, feel free to open an issue or submit a pull request on [GitHub](https://github.com/resumeupai/resume-parser-ai).

We appreciate your contributions! 😊
predi 0.1.14
PreDi: Symbolic Solidity Predicate Difference Tool
Requires Python: >=3.8

# PreDi: Symbolic Solidity Predicate Difference Tool

PreDi is a tool to compare two predicates written in Solidity, the smart contract programming language. PreDi determines if two predicates are equivalent or if one is stronger than the other.

## Features

- Tokenizes and parses each Solidity predicate into an Abstract Syntax Tree (AST)
- Simplifies AST using symbolic mathematics
- Compare predicates for equivalence and logical strength either using predefined rules (when applicable) or checking for satisfiability when pre-defined rules are not applicable.

## Install Using pip and Use as a Python Library

Running the following command should suffice:

```sh
pip install predi
```

### Library Usage

#### Simple Predicate Comparison

```Python
>>> from predi.comparator import Comparator
>>> comparator = Comparator()
>>> comparator.compare("a < b", "a <= b")
'The first predicate is stronger.'
>>> comparator.compare("a > b", "a <= b")
'The predicates are not equivalent and neither is stronger.'
```

## Installing and Using as a CLI Tool

### Prerequisites

- Python 3.8 or higher
- Install required packages using pip

```sh
pip install -r requirements.txt
```

### Running the Tests

To ensure everything is set up correctly, run the unit tests:

```sh
python -m unittest discover -s tests
```

### CLI Usage

You can compare two predicates using the `main.py` script. Here's an example:

```sh
$ python main.py "msg.sender == msg.origin" "msg.origin == msg.sender"
The predicates are equivalent.

$ python main.py "msg.sender == msg.origin && a >= b" "msg.sender == msg.origin"
The first predicate is stronger.

$ python main.py "msg.sender == msg.origin || a < b" "a < b"
The second predicate is stronger.
```
st-multimodal-chatinput 0.2.1
Streamlit component that allows you to accept multi-modal inputs through a chat interface.
Requires Python: >=3.7


# Streamlit Multimodal Chat Input

A Streamlit component that enables a rich multimodal chat interface, allowing users to input text and upload images within Streamlit applications.
Demo video at [Streamlit Community Forum](https://discuss.streamlit.io/t/new-component-st-multimodal-chatinput-lets-you-accept-files-through-a-chat-like-interface/54935).

## Features

- **Text Input**: Users can type in their messages.
- **Image Upload**: Supports uploading images, enhancing the chat with a visual element.
- **Clipboard Paste**: Enables pasting images directly from the clipboard.
- **Responsive Design**: Adjusts to the width of the Streamlit container.
- **Disabled State**: Can be set to a disabled state, making the input and button non-interactive and visually distinct.

## Installation Instructions

To install the component, run the following command:

```sh
pip install st-multimodal-chatinput
```

## Usage instructions

```python
import streamlit as st

from st_multimodal_chatinput import multimodal_chatinput

chatinput = multimodal_chatinput()

uploaded_files = chatinput["uploadedFiles"] ##list of ALL uploaded files (including images) along with type, name, and content.
uploaded_images = chatinput["uploadedImages"] ## list of base 64 encoding of uploaded images
text = chatinput["textInput"] ##submitted text
for file in uploaded_files:
    filename = file["name"]
    filetype = file["type"] ## MIME type of the uploaded file
    filecontent = file["content"] ## base 64 encoding of the uploaded file
```

## Common MIME types

| File Extension | MIME Type |
| -------------- | --------- |
| .pdf           | application/pdf |
| .doc          | application/msword |
| .csv          | text/csv |

You can find other common types [here](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types).


## Contributing

Pull requests for some of the to-dos are more than welcome.
urduhack-lite 0.2.0
Natural Language Processing (NLP) library for Urdu language.
Requires Python: >=3.8

# Urduhack-lite: A lighter Urduhack

**Unless otherwise mentioned, _ALL_ code is taken directly from the original [Urduhack](https://githuh.com/urduhack/urduhack/) library.
This is merely a stripped down version of the original.**

For more information, refer to the original [library](https://github.com/urduhack/urduhack).

You can reach out core contributor Mr Ikram Ali @ https://github.com/akkefa

## Features Support

- [x] Normalization
- [ ] Preprocessing
- [x] Tokenization
  - [x] Sentence tokenization
  - [ ] Word tokenization
- [ ] Pipeline Module
- [ ] Models
  - [ ] Pos tagger
  - [ ] Lemmatizer
  - [ ] Name entity recognition
  - [ ] Sentimental analysis
  - [ ] Image to text
  - [ ] Question answering system
- [ ] Datasets loader
energytstoolkit 0.1.2
A toolkit for time series preprocessing, feature engineering, and forecasting
Requires Python: >=3.6

# Energy Time Series Toolkit

Time Series Toolkit is a Python package developed as a group project at OpenCampus Kiel. It provides a set of tools for preprocessing, feature engineering, and analysing time series data, as well as implementing LSTM models for time series forecasting.

## Features

- Time series preprocessing
- Feature engineering for time series data
- Time series decomposition and stationarity checks
- LSTM model creation and training for time series forecasting
- Model evaluation utilities

## Installation

You can install the Time Series Toolkit using pip:

```bash
pip install energytstoolkit