semvec/pypi-packages huggingface dataset:
jito_searcher_client_no_auth 0.1.9
Jito Labs Python Searcher Client
Requires Python: <4.0,>=3.10

# About
This library contains tooling to interact with Jito Lab's Block Engine as a searcher.

# Downloading
```bash
$ pip install jito_searcher_client
```

# Keypair Authentication
Basic access(5 req/second per region) no longer requires approval. Please visit our [Discord](https://discord.gg/jito) dev channel, if you have other questions.
If your application requires higher rate limits, please complete this [form](https://forms.gle/8jZmKX1KZA71jXp38)

# Examples

## Sync Client

```python
from jito_searcher_client import get_searcher_client
from jito_searcher_client.generated.searcher_pb2 import ConnectedLeadersRequest

from solders.keypair import Keypair

BLOCK_ENGINE_URL = "nyc.testnet.block-engine.jito.wtf"

kp = None
client = get_searcher_client(BLOCK_ENGINE_URL, kp)
leaders = client.GetConnectedLeaders(ConnectedLeadersRequest())
print(f"{leaders=}")
```

## Async Client

```python
import asyncio

from jito_searcher_client import get_async_searcher_client
from jito_searcher_client.generated.searcher_pb2 import ConnectedLeadersRequest

from solders.keypair import Keypair

KEYPAIR_PATH = "/path/to/authenticated/keypair.json"
BLOCK_ENGINE_URL = "frankfurt.mainnet.block-engine.jito.wtf"

async def main():
    with open(KEYPAIR_PATH) as kp_path:
        kp = Keypair.from_json(kp_path.read())
    client = await get_async_searcher_client(BLOCK_ENGINE_URL, kp)
    leaders = await client.GetConnectedLeaders(ConnectedLeadersRequest())
    print(f"{leaders=}")

asyncio.run(main())
```

# Development

Install pip
```bash
$ curl -sSL https://bootstrap.pypa.io/get-pip.py | python 3 -
```

Install poetry
```bash
$ curl -sSL https://install.python-poetry.org | python3 -
```

Setup environment and build protobufs
```bash
$ poetry install
$ poetry shell
$ poetry protoc
```

Linting
```bash
$ poetry run black .
$ poetry run isort .
```

Linting:
```bash
poetry run isort .
poetry run black .
```

Publishing package
```bash
$ poetry protoc && poetry build && poetry publish
```
symdr 1.0.3
Find dispersion relation in PDE, systems of PDE, and discrete analogs
Requires Python: >=3.7
Keywords: PDE, Continuum mechanics, computer algebra, python

SymDR
========
SymDR is a library made to automate the process of finding dispersion relations.

It was created in The Great Mathematical Workshop 2024 by the command of young ambitious scientists.

Features
===========
Finding dispersion relation in:
- Equations
- System of equations
- Discrete equations
- Systems of discrete equations


Quickstart
=============
For the best experience, we highly recommend using [Jupyter Notebook](https://jupyter.org/) or [Google Collab](https://colab.research.google.com).

SymDR supports [Python](http://python.org/) >=3.7 and only depends on [Sympy](https://www.sympy.org).
Install the Python package using pip.
```
pip install symdr
```

Example
==========
- If you are new to symbolic mathematics in Python, read SymPy [introduction](https://docs.sympy.org/latest/tutorials/intro-tutorial/index.html) first.
- For the end-to-end example of equation analysis, see [notebook](https://github.com/symdr/symdr/blob/master/example.ipynb).

>!!!!!!! IMPORTANT !!!!!!!!
>Variables `x`, `t`, `w`, `k` must not be redefined. They are used by the algorithm. When working with discrete cases, the variables `h`, `tau`, `a` and `n` are also added to this list.


SymDR has own objects for grid functions. To turn on pretty-printing for these functions, you need to add:

```
init_printing(latex_printer=discrete_latex_printer)
```
Creation of a grid function is the same as standart function:

```
u = DiscreteGrid('u')
```

Consider a discrete analog of Korteweg–De Vries equation:

$$u_{t}=6uu_{x}-u_{xxx}$$


For the third order derivative, we are going to use next scheme:
$$ f^{(3)}(x)=\frac{f(x+2h)-2f(x+h)+2f(x-h)-f(x-2h)}{2h^3}$$

And we can write our equation
```
equation = u.diff(t) + (u.at_x(a+2) - 2 * u.at_x(a+1) + 2 * u.at_x(a-1) - u.at_x(a-2)) / (2 * h ** 3)
```
>The class allows us to denote a derivative at (a, n) with "diff" method exactly the same way as SymPy functions do.
>Shift at a point is done by any of three methods:
>- at_x - shift in space (i.e. ```u.at_x(a+2)``` means $u_{a+2}^n$)
>- at_t - shift in time (i.e. ```u.at_t(n-2)``` means $u_a^{n-2}$)
>- at - shift in both axes at once (i.e. ```u.at(a+2, n-1)``` means $u_{a+2}^{n-1}$)

>Technical note: instead of moving the function into a subtree of ```Derivative``` object, as it is with SymPy functions, differentiation of ```DiscreteGrid``` object simply returns an object of the same class, but with different arguments.

Finally, let's find dispersion relation:

```
d_equation_dr(equation)
```
Also you can rewrite it with Euler formula:

```
d_equation_dr(equation, trig_rewrite=True)
```

And here's the full code:

```
from sympy import *
from symdr import *

u = DiscreteGrid('u')
equation = u.diff(t) + (u.at_x(a+2) - 2 * u.at_x(a+1) + 2 * u.at_x(a-1) - u.at_x(a-2)) / (2 * h ** 3)

d_equation_dr(equation)
```
prelawsql 0.0.11
Fetch, store, process files prior to database insertion.
Requires Python: >=3.11

# prelawsql

![Github CI](https://github.com/justmars/corpus-reader/actions/workflows/ci.yml/badge.svg)

Attempts uniform underlying functions for reading from and writing to locally downloaded corpus repositories:

1. [Decision](https://github.com/justmars/corpus-decisions)
2. [Statute](https://github.com/justmars/corpus-statutes)
3. [Codifications](https://github.com/justmars/corpus-codifications)

## Config

```sh
just start
source .venv/bin/activate
just dumpenv
pre # show db-based commands
```