semvec/pypi-packages huggingface dataset:
md2steam 1.0.1
Markdown to Steam BBCode converter
Requires Python: >=3.10

### Installing
```
pip install md2steam
```

### Example
```python
from md2steam import markdown_to_steam_bbcode

md_text = """
# Пример заголовка

Текст с **жирным**, *курсивом* и [ссылкой](https://example.com).
"""

bbcode_text = markdown_to_steam_bbcode(md_text)
print(bbcode_text)
```
ParkerO 0.0.1
ParkerO is a Python-based implementation of the Parker-Oldenburg Algorithm for calculating gravity anomalies from a density interface and Recovering the density interface from gravity anomalies.
Requires Python: >=3.6

# ParkerO

### Abstract
`ParkerO` is a Python-based algorithm implementation of the Parker-Oldenburg method for: 
1. **Forward modeling**: Calculating gravity anomalies from the density interface.  
2. **Inverse modeling**: Recovering the density interface from gravity anomalies.  

### Key Features  
- A Parker-Oldenburg toolkit containing:  
  - Forward program (`density interface → gravity anomalies`).  
  - Inversion program (`gravity anomalies → density interface`), optimized for reconstructing **seafloor topography** from gridded gravity data.  
- Extended capability to handle **variable density-contrast scenarios** (implemented in this package).  
- **Critical note**: When `mu=0`, the variable density-contrast formula simplifies to the original Parker-Oldenburg method.  

### Functionality  
✅ Parameter tuning for constant/variable density-contrast models.  
✅ Regional adaptability for seafloor topography inversion.  
✅ Built-in visualization tools for forward/inverse results.
resume-copilot-lib 1.0.0
A Python library to interact with the Resume Copilot API, allowing job search integration into applications.
Requires Python: >=3.6

# ResumeCopilot Python Library

## Overview
ResumeCopilotLib is a Python library designed to interact with the Resume Copilot API, allowing developers to integrate job search functionality into their applications.

## API Documentation
For detailed API documentation, visit:  
[Resume Copilot API](https://api.resumecopilot.net/swagger/index.html)

## What is Resume Copilot?
Resume Copilot is your one-stop solution for crafting the perfect resume. It is available as a plugin in the ChatGPT Plus version, helping users streamline their resume-building process. With Resume Copilot, you can:

- Effortlessly upload and edit resumes
- Make precise improvements and enhancements
- Choose from a diverse range of professional templates
- Navigate and implement suggested changes with ease

To learn more, visit:  
[Resume Copilot Website](https://resumecopilot.net/)

## ChatGPT Plugin
Resume Copilot is also available as a ChatGPT plugin to enhance your resume-writing experience. You can access it here:  
[Resume Copilot on ChatGPT](https://chatgpt.com/g/g-EcIzZRYVx-resume-copilot)

## Installation
To install the ResumeCopilot Python library via pip, use the following command:
```sh
pip install resume-copilot-lib
```

## Usage
Here's a basic example of how to use the library to perform a job search:
```python
from resume_copilot_lib import JobSearchHelper, JobSearchRequest

request = JobSearchRequest(
    title="developer",
    size=2
)

results = JobSearchHelper.search_jobs(request)
for job in results.jobs:
    print(f"Job: {job.name} at {job.company_name}")
```

## Contributing
We welcome contributions! Feel free to open issues or submit pull requests to improve the library.

## License
This project is licensed under the MIT License.
streamlit-editorjs-component 0.1.5
editorjs component for streamlit
Requires Python: >=3.7

# streamlit-editor-js-component

Custom component for editorjs.  
[Editorjs](https://editorjs.io/) is json-based rich-text-editor.  

## Installation
``` bash
pip install streamlit-editorjs-component
```

## Getting started

``` python
import streamlit as st
from streamlit-editorjs-component import streamlit_editorjs

content = streamlit_editorjs(height=500)
st.write(content)
```

``` plain text
Args:  
    data (dict, optional): initial json data formatted as EditorJS. Defaults to None.  
    key (str, optional): Streamlit state key. Defaults to None.  
    height (int, optional): Component block height it the content over the height, it makes scroll. Defaults to 500.
    readonly (bool, optional): Readonly mode [not updated in PYPI.]

Returns:  
    dict: dictionary content from EditorJS.
```

## For developer

### Add new plugins

Add tools to [constant.js](streamlit_editorjs_component/frontend/src/components/constant.js)  

``` bash
yarn install
yarn build
```

``` bash
streamlit run test/st_component_example.py
```
cobra-engine 0.1.0
A tiny portable OpenGL framework using PyGame
Requires Python: >=3.8

# The Cobra Engine
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec venenatis nulla nisl, in porta nibh malesuada eget. Nam lobortis sit amet lorem et faucibus. Donec neque lectus, rutrum sit amet justo sed, aliquam gravida lacus. Quisque nec ex leo. Integer ac neque nulla. Proin at blandit nibh. Sed eget erat eu lectus fringilla sollicitudin. Nulla iaculis nisl non est consequat sagittis. Pellentesque pretium ac sapien ac blandit.

Nullam vitae augue nisl. Sed sit amet ultricies ipsum. Mauris nec urna elit. Vestibulum vel venenatis odio. Curabitur ut libero luctus, porttitor ante vitae, bibendum metus. Suspendisse fermentum elementum dictum. Nam vulputate consequat metus, ut egestas libero laoreet eu.

Morbi lacinia malesuada metus, dapibus pharetra turpis mattis nec. Vestibulum ut mollis libero. Vivamus vehicula convallis tincidunt. Nunc iaculis velit eget lacus elementum pellentesque. Nullam fringilla lorem ac commodo porttitor. Aenean sit amet nunc euismod, aliquet dolor at, consequat elit. Nunc sit amet tortor condimentum, iaculis sapien at, consectetur sapien.

Integer metus quam, faucibus non mollis sit amet, faucibus a nunc. Nam in pellentesque nibh, vel sagittis ante. In vitae nisl felis. Etiam tempor enim sit amet sapien aliquam, non sollicitudin arcu accumsan. Praesent consectetur enim urna, id pellentesque felis aliquam sit amet. Duis rutrum iaculis maximus. Fusce porta mauris ac nulla euismod viverra. Ut pellentesque scelerisque condimentum. Ut pellentesque convallis leo, ac tincidunt urna fermentum ut. Phasellus facilisis orci sit amet ultrices mattis.

Donec elementum dictum tellus, sit amet dapibus risus faucibus condimentum. Ut posuere libero sit amet lorem pellentesque consequat. Curabitur vulputate porttitor orci ac mattis. Phasellus suscipit in lacus sit amet egestas. Nulla elit ligula, volutpat ut leo vitae, vehicula dictum nisl. Mauris nisl mi, faucibus at vestibulum quis, consequat mollis turpis. Vestibulum eget pretium leo.
scriptengine 1.2.0
A lightweight and extensible framework for executing scripts written in YAML
Requires Python: >=3.8

# ScriptEngine

![Tests](https://github.com/uwefladrich/scriptengine/actions/workflows/pytest.yml/badge.svg)
![Test coverage](https://coveralls.io/repos/github/uwefladrich/scriptengine/badge.svg)
![PyPI package](https://img.shields.io/pypi/v/scriptengine?color=green)
![Conda-forge package](https://img.shields.io/conda/vn/conda-forge/scriptengine?color=green)


ScriptEngine is a lightweight and extensible framework for executing scripts
written in YAML. The main purpose of ScriptEngine is to replace shell scripts
in situations where highly configurable and modular scripts are needed.
ScriptEngine relies on [YAML](https://yaml.org/) and makes extensive use of
[Jinja2](https://palletsprojects.com/p/jinja/) templating to provide a
comprehensive scripting language. This allows users to put focus on the
description of tasks, rather than their implementation. The description of
complex tasks should be nearly as short and clear as for simpler ones.

The ScriptEngine concept separates scripts (*what* to do) from the
implementation of tasks (*how* to do things), and also from the actual
execution environment (the script engine instances). This modularity allows the
provision of different execution models (e.g. sequential or parallel; local or
remote) within the same framework.

ScriptEngine provides a concise set of basic tasks that users can use to write
their scripts. However, extensibility is a fundamental principle for
ScriptEngine. Complementary task sets are provided as Python packages that can
be loaded into ScriptEngine at run time. Thus, the capabilities of ScriptEngine
scripts is only limited by available task sets.

ScriptEngine tasks are simple Python classes with a `run()` method, which means
that it is rather easy to build new tasks sets for particular needs. And
because everything is based on Python3, there is a wide range of modules
available to get the actual work done easily and efficiently.

ScriptEngine is [open source](LICENSE) software, hosted at
[GitHub](https://github.com/uwefladrich/scriptengine). Up-to-date ScriptEngine
packages are provided at [PyPI](https://pypi.org/project/scriptengine/) and
[conda-forge](https://anaconda.org/conda-forge/scriptengine), so installation is
as easy as `pip install scriptengine` or `conda install scriptengine`.
Documentation, including more detailed installation instructions, is published
at [ReadtheDocs](https://scriptengine.readthedocs.io/en/latest/).