semvec/pypi-packages huggingface dataset:
builtsimple-jupyter 1.0.0
Jupyter magic commands for PubMed, ArXiv, Wikipedia search

# builtsimple-jupyter

Jupyter magic commands for searching PubMed, ArXiv, and Wikipedia.

## Installation

```bash
pip install builtsimple-jupyter
```

## Usage

```python
# Load the extension
%load_ext builtsimple_jupyter

# Search individual sources
%pubmed cancer treatment
%arxiv transformer attention
%wiki machine learning

# Search all sources
%research neural networks
```

## Powered By

[Built-Simple.ai](https://built-simple.ai) Research APIs
yesig 0.1.1
A simple python interface for the signal-cli rest api. With support for the json-rpc websocket via asyncio
Requires Python: >=3.14.2

YESIG

Yes another python interface for the signal-cli rest api.
Simple and Effictent just YESIG!

Set the envoirment var SIGNAL_ACCOUNT with the signal account in use!
This Interface is built on requests and websockets for a live jsonrpc asyncio mode.

Installation:

    python -m pip install yesig


Received Messages are stored as dataclasses such as ReceivedMessage ReceivedPreview ReceiptMessage where the first two are able to contain ReceivedAttachment's.


Receiving messages can be as simple as:
        
        receiver = RestReceiver(port=1312, attachment_folder=~/signal_attachments)
        msgs = receiver.receive()

Or live:
        
        await receive_from_socket(queue=q) # Run as a asyncio.thread for example



To send message simply call:

        Transmitter().send([+99999999, ThisIsAUsername.777, MyReallyCoolGroup], msg="Hello world", attachments=["funny_duck.jpg"])


Download an attachment with the receiver:
        
        fpath = Receiver().download(AttachmentId)


To send a preview use a preview object:        

        preview=Preview(url="https://wiki.archlinux.org",title="i use", description="Arch btw", filepath="/path/to/funnier_duck.jpg")
        Transmitter().send("+5512344567", msg="Hey dude\nDid you know:" preview=preview)



Planned features:

* Mentions
* Reply
* Edit Messages
* React
* Send/Stop writing
* Create/Delete Groups
* Fully asyncio|aiohttp support

Goal is to have a simple yet efficient and pythonic interface for the signal-rest api.
jaxspec 0.3.4
jaxspec is a bayesian spectral fitting library for X-ray astronomy.
Requires Python: <3.13,>=3.10

<p align="center">
  <img src="https://raw.githubusercontent.com/renecotyfanboy/jaxspec/main/docs/logo/logo_small.svg" alt="Logo" width="100" height="100">
</p>

<h1 align="center">
  jaxspec
</h1>


[![PyPI - Version](https://img.shields.io/pypi/v/jaxspec?style=for-the-badge&logo=pypi&color=rgb(37%2C%20150%2C%20190))](https://pypi.org/project/jaxspec/)
![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Frenecotyfanboy%2Fjaxspec%2Frefs%2Fheads%2Fmain%2Fpyproject.toml&style=for-the-badge)
[![Read the Docs](https://img.shields.io/readthedocs/jaxspec?style=for-the-badge)](https://jaxspec.readthedocs.io/en/latest/)
[![Codecov](https://img.shields.io/codecov/c/github/renecotyfanboy/jaxspec?style=for-the-badge)](https://app.codecov.io/gh/renecotyfanboy/jaxspec)
[![Slack](https://img.shields.io/badge/Slack-4A154B?style=for-the-badge&logo=slack&logoColor=white)](https://join.slack.com/t/jaxspec/shared_invite/zt-2cuxkdl2f-t0EEAKP~HBEHKvIUZJL2sg)

> :warning: **jaxspec is still in early release**: expect bugs, breaking API changes, undocumented features and lack of functionalities

`jaxspec` is an X-ray spectral fitting library built in pure Python. It can currently load an X-ray spectrum (in the OGIP standard), define a spectral model from the implemented components, and calculate the best parameters using state-of-the-art Bayesian approaches. It is built on top of JAX to provide just-in-time compilation and automatic differentiation of the spectral models, enabling the use of sampling algorithm such as NUTS.

`jaxspec` is written in pure Python, and has no dependancy to [HEASoft](https://heasarc.gsfc.nasa.gov/docs/software/heasoft/), and can be installed directly using the `pip` command.

Documentation : https://jaxspec.readthedocs.io/en/latest/

## Installation

We recommend the users to start from a fresh Python 3.10 [conda environment](https://conda.io/projects/conda/en/latest/user-guide/install/index.html).

```
conda create -n jaxspec python=3.10
conda activate jaxspec
```

Once the environment is set up, you can install jaxspec directly from pypi

```
pip install jaxspec --upgrade
```

## Citation 

If you use `jaxspec` in your research, please consider citing the following article 

```
@ARTICLE{2024A&A...690A.317D,
       author = {{Dupourqu{\'e}}, S. and {Barret}, D. and {Diez}, C.~M. and {Guillot}, S. and {Quintin}, E.},
        title = "{jaxspec: A fast and robust Python library for X-ray spectral fitting}",
      journal = {\aap},
     keywords = {methods: data analysis, methods: statistical, X-rays: general},
         year = 2024,
        month = oct,
       volume = {690},
          eid = {A317},
        pages = {A317},
          doi = {10.1051/0004-6361/202451736},
       adsurl = {https://ui.adsabs.harvard.edu/abs/2024A&A...690A.317D},
      adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}
```
pydantic-rpc-cli 0.15.2
CLI tool for pydantic-rpc with server runtime support
Requires Python: >=3.11

# pydantic-rpc-cli

CLI tool for [pydantic-rpc](https://github.com/yourusername/pydantic-rpc) with built-in server runtime support.

## Installation

```bash
pip install pydantic-rpc-cli
```

This will install:
- `pydantic-rpc` (core library)
- `hypercorn` (ASGI server)
- `gunicorn` (WSGI server)
- `uvloop` (optional asyncio performance improvement)

## Usage

### Generate Protobuf Files

```bash
# Generate .proto file from a service class
pydantic-rpc generate myapp.services.UserService --output ./proto/

# Also compile to Python code
pydantic-rpc generate myapp.services.UserService --compile
```

### Run Servers

#### gRPC Server (default)
```bash
# Start a gRPC server
pydantic-rpc serve myapp.services.UserService --port 50051

# The CLI automatically detects if your service has async methods
# and uses AsyncIOServer or Server accordingly
```

#### Connect RPC via ASGI (HTTP/2)
```bash
# Run with Hypercorn (built-in)
pydantic-rpc serve myapp.services.UserService --asgi --port 8000

# Service will be available at:
# http://localhost:8000/UserService/
```

#### Connect RPC via WSGI (HTTP/1.1)
```bash
# Run with Gunicorn (built-in)
pydantic-rpc serve myapp.services.UserService --wsgi --port 8000

# With multiple workers
pydantic-rpc serve myapp.services.UserService --wsgi --port 8000 --workers 4

# Service will be available at:
# http://localhost:8000/UserService/
```

## Example Service

```python
# myapp/services.py
from pydantic_rpc import Message, AsyncIOServer

class HelloRequest(Message):
    name: str

class HelloResponse(Message):
    message: str

class GreeterService:
    async def say_hello(self, request: HelloRequest) -> HelloResponse:
        return HelloResponse(message=f"Hello, {request.name}!")
```

Run it:
```bash
# As gRPC
pydantic-rpc serve myapp.services.GreeterService

# As Connect RPC (HTTP/2)
pydantic-rpc serve myapp.services.GreeterService --asgi --port 8000

# As Connect RPC (HTTP/1.1)
pydantic-rpc serve myapp.services.GreeterService --wsgi --port 8000
```

## Benefits of the Separated CLI

- **Lightweight Core**: The main `pydantic-rpc` package remains lightweight without server dependencies
- **Full Server Support**: When you install `pydantic-rpc-cli`, you get everything needed to run services
- **Flexibility**: Choose between gRPC, ASGI (HTTP/2), or WSGI (HTTP/1.1) at runtime

## License

Same as pydantic-rpc