semvec/pypi-packages huggingface dataset:
get-code-from-markdown 1.0.1
extract code from within triple-quotes (```) in markdown files
Requires Python: >=3.10

# get_code_from_markdown

Extract code from within triple-quotes (```) in markdown files (code blocks).

## Usage

### Getting code blocks from markdown files

The `language` parameter defaults to `python`. This will find codeblocks that start with **\`\`\`python**

```python
from get_code_from_markdown import *

blocks = get_code_from_markdown(["# get_code_from_markdown", "```python", "print('hello world')", "```"])
# or
blocks = get_code_from_markdown_filename("README.md", language="python")
# or
with open("README.md", "r") as f:
    blocks = get_code_from_markdown_file(f, language="python")
```

### Running code blocks from markdown files

You can use a subprocess or just exec the code to see if it works.

```python
from get_code_from_markdown import run_code_from_markdown_blocks
blocks = ["print('hello world')"]

# run function uses exec() by default
run_code_from_markdown_blocks(blocks)

# you can choose to use subprocess output instead
# this will use python3 by default
run_code_from_markdown_blocks(blocks, method=RunMethods.SUBPROCESS)

# give arguments to specify a different command
run_code_from_markdown_blocks(blocks, method=RunMethods.SUBPROCESS(["python3", "-c"]))
```

### Format of outputted code blocks

The format is a list of `\n`-delimited strings, each representing a block of code from the parsed markdown file. You can split the code blocks further into individual lines of code with `string.split("\n")`

## Development

- Use `black` (code linter)
- Run `pytest` (unit tests)
- Build a package for PyPI: `python -m build --sdist --wheel`

## Legal

This is a derivative work of [Codeblocks](https://github.com/shamrin/codeblocks) which provides a simpler version with less dependencies. It is covered by the same Apache license (see `LICENSE` file in this git repo). Use Codeblocks for its CLI and automatic formatting features.
berconpy 3.1.2
An async wrapper for the BattlEye RCON protocol
Requires Python: >=3.10

# berconpy

[![PyPI](https://img.shields.io/pypi/v/berconpy?label=View%20on%20pypi&style=flat-square)](https://pypi.org/project/berconpy/)
[![Docs](https://readthedocs.org/projects/berconpy/badge/?style=flat-square)](http://berconpy.readthedocs.io/)
[![](https://img.shields.io/github/actions/workflow/status/thegamecracks/berconpy/python-publish.yml?style=flat-square&logo=uv&label=build)](https://docs.astral.sh/uv/)
[![](https://img.shields.io/github/actions/workflow/status/thegamecracks/berconpy/python-test.yml?style=flat-square&logo=pytest&label=tests)](https://docs.pytest.org/en/stable/)
[![](https://img.shields.io/github/actions/workflow/status/thegamecracks/berconpy/ruff-check.yml?style=flat-square&logo=ruff&label=lints)](https://docs.astral.sh/ruff/)
[![](https://img.shields.io/github/actions/workflow/status/thegamecracks/berconpy/ruff-format.yml?style=flat-square&logo=ruff&label=style)](https://docs.astral.sh/ruff/)

An asynchronous Python wrapper over the [BattlEye RCON protocol][1].

## Features

- Easy to use event-based interface
- Automatic network loss recovery
- Included extension for Arma 3 commands and events

## Basic Usage

```py
import asyncio
import berconpy

client = berconpy.RCONClient()

IP = "XXX.XXX.XXX.XXX"
PORT = 9999
PASSWORD = "ASCII_PASSWORD"

@client.dispatch.on_login
async def on_login():
    print("We have logged in!")

async def main():
    async with client.connect(IP, PORT, PASSWORD):
        players = await client.send_command("players")
        print(players)

asyncio.run(main())
```

See the [documentation][2] for more details.

## Migrating to v3

v3.0.0 is a major rewrite of this library to isolate generic BattlEye RCON functionality
from Arma 3 / DayZ-specific features. For users that need to work with other games like
Arma Reforger, you must use v3.

For v2 users that cannot migrate, ensure that your requirements are pinned
to `berconpy~=2.1` to prevent accidentally upgrading to v3.
[v2 documentation] is still available for the time being.

[v2 documentation]: https://berconpy.readthedocs.io/en/v2.1.4/

## Installation

(**Python 3.10** or higher is required)

This package can be installed from PyPI using the following command:

```
# Linux/macOS
python3 -m pip install berconpy

# Windows
py -m pip install berconpy
```

If you want to install the development version instead, and you have git installed:

```
pip install git+https://github.com/thegamecracks/berconpy
```

## Related resources

- [BattlEye RCON protocol specification][1]
- [BattlEye RCON commands](https://www.battleye.com/support/documentation/)
- [Arma server commands](https://community.bistudio.com/wiki/Multiplayer_Server_Commands)

## License

This project uses the [MIT][3] License.

[1]: https://github.com/thegamecracks/berconpy/blob/main/docs/source/BERConProtocol.txt
[2]: https://berconpy.readthedocs.io/en/stable/
[3]: https://github.com/thegamecracks/berconpy/blob/main/LICENSE
iflow-mcp_byron993-google_scholar_mcp 0.1.0
Add your description here
Requires Python: >=3.11

# Google Scholar MCP Server (Optimized for Cherry Studio)

An MCP-based Google Scholar search service optimized for Cherry Studio, providing academic paper search, abstract retrieval, and supporting both Chinese and English queries.

## Features

- Search academic papers via Google Scholar (not limited to arXiv)
- Automatically retrieve and filter paper abstracts (only keeping complete abstracts)
- Support Chinese keyword search with auto-translation to English
- Return comprehensive paper metadata (title, authors, journal, year, citations, URL, etc.)
- Optimized for Cherry Studio integration via MCP protocol

## Installation

`google_scholar_mcp` can be installed using `uv`. Below are two approaches: a quick start for immediate use and a detailed setup for development.

### Quick Start

For users who want to quickly run the server:

1. **Install Package**:
   ```bash
   uv add google_scholar_mcp
   ```

2. **Configure Cherry Studio**:
   Add this configuration to your Cherry Studio configuration file:
   ```json
   {
     "mcpServers": {
       "google_scholar_server": {
         "command": "uv",
         "args": [
           "--directory",
           "/path/to/your/google_scholar_mcp",
           "run",
           "gsd_mcp.py"
         ]
       }
     }
   }
   ```
   > Note: Replace `/path/to/your/google_scholar_mcp` with your actual installation path.

## Usage

### Response Example

```text
=== Paper 1 ===
Title: Deep Learning
Authors: Yann LeCun, Yoshua Bengio, Geoffrey Hinton  
Journal: Nature
Year: 2015
URL: https://www.nature.com/articles/nature14539
Citations: 95183
Abstract:
  Deep learning allows computational models composed of multiple processing layers to learn representations of data with multiple levels of abstraction...
```

## Notes

1. Abstract retrieval depends on paper page structure and may not always succeed
2. VPN connection is required throughout usage to access Google Scholar
3. Please set reasonable request frequency to avoid being blocked by Google Scholar
4. Chinese queries are automatically translated to English for searching

## Dependencies

- googletrans>=4.0.2
- httpx>=0.28.1
- mcp[cli]>=1.7.0
- scholarly>=1.7.11

## License

MIT License
catune 0.1.0
CaTune companion: calcium imaging deconvolution and data preparation
Requires Python: >=3.10
Keywords: FISTA, calcium-imaging, deconvolution, neuroscience, spike-inference

# CaTune Python Companion

Calcium imaging deconvolution and data preparation -- Python companion package for the [CaTune](https://github.com/daharoni/CaTune) browser tool.

## Installation

```bash
pip install catune
```

## Quick Start

```python
import catune

# Build a calcium kernel
kernel = catune.build_kernel(tau_rise=0.02, tau_decay=0.4, fs=30.0)

# Get AR(2) coefficients
g1, g2, d, r = catune.tau_to_ar2(tau_rise=0.02, tau_decay=0.4, fs=30.0)

# Compute Lipschitz constant for FISTA step size
L = catune.compute_lipschitz(kernel)
```
jemo-admin 0.1.4
A CLI tool to scaffold modern web projects with FastAPI, Django, Convex, Next.js, SvelteKit, or TanStack Start.
Requires Python: >=3.12

# Jemo Admin CLI

A powerful CLI tool to scaffold modern web projects with your favorite stack.

## Supported Stacks

**Backend:**
- **FastAPI** (with Tortoise ORM & Aerich)
- **Django**
- **Convex** (Serverless)

**Frontend:**
- **Next.js**
- **SvelteKit**
- **TanStack Start**

## Installation

You can install `jemo-admin` using `pipx`:

```bash
pipx install .
# Or from a git repo:
# pipx install git+https://github.com/Jemo69/create-jemo-app.git
```

## Usage

Create a new project interactively:

```bash
jemo-admin create
```

Or specify the project name directly:

```bash
jemo-admin create my-awesome-app
```

Follow the interactive prompts to select your backend and frontend framework.

## Requirements

- **Python 3.12+**
- **Bun** (for frontend package management)
- **UV** (for Python package management)
Note : it does not work on Windows.