semvec/pypi-packages huggingface dataset:
p2p-exnode-sdk 0.0.2
A P2P exnode SDK
Requires Python: >=3.6

```python
from p2p_exnode_sdk import *

if __name__ == "__main__":
    request = GetActiveOffersParams(
        fiat="RUB",  # RUB or KZT or UZS or TJS
        crypto="USDTTRC",
        amount="",
        banks="SBERRUB,TCSBRUB,RFBRUB,SBPRUB,INTERBRUB,VTBRUB,OPNBRUB,MTSBRUB,ACRUB,RSHBRUB,GPBRUB,POSTBRUB,SOVKRUB,MKBRUB,YMRUB,PHONERUB,CASHRUB",
        type="buy",
        page=1,
        limit=100,
        sort="rate_asc"
    )

    response = get_active_offers(request)

    interesting_user = None
    interesting_offer = None

    for info in response.info:
        offer = info.offer
        user = info.user

        if user.nickname == "some_nickname":
            interesting_offer = offer
            interesting_user = user
            print(f"interesting offer found: {offer}")
            print(f"interesting user found: {user}")
            break

    if interesting_offer is None:
        print("interesting offer not found")
        exit(0)

    request = PostSignInRequest(
        email="your_email",
        password="your_password"
    )

    response = post_sign_in(request)

    access = response.data.access
    refresh = response.data.refresh

    response = get_via_offer(interesting_offer.internal_id, access, refresh)

    interesting_data = None

    for data in response.data:
        # if data.tech == "SBERRUB":
        #     interesting_data = data
        #     print(f"interesting data found: {data}")
        #     break

        interesting_data = data
        print(f"interesting data found: {data}")
        break

    if interesting_data is None:
        print("interesting data not found")
        exit(0)

    request = PostOrdersInitRequest(
        internal_id=interesting_offer.internal_id,
        taker="your_nickname",
        maker=interesting_user.nickname,
        amount_from=120,
        amount_to=1,
        crypto="USDTTRC",
        fiat="SBERRUB",
        req_id=interesting_data.id,
        address=""
    )

    response = post_orders_init(request, access, refresh)

    print(f"awaiting payment")
```
ros-introspect 0.3.0
Pure Python library for working with the files in ROS packages
Requires Python: >=3.8

![ros_introspect logo](docs/Logo.png)

 `ros_introspect` is a Pure Python library for working with the files in ROS packages in a structured way.
It is compatible with both ROS 1 and ROS 2.

You can specify the path directly.

```
from ros_introspect import Package
package = Package('/full/path/geometry_msgs')
```
or you can use the built-in crawler to search recursively

```
from ros_introspect import find_packages

for package in find_packages('/home/dlu/ros2_ws/src'):
    print(package)
```

## Installation

[![PyPI version](https://badge.fury.io/py/ros-introspect.svg)](https://badge.fury.io/py/ros-introspect)

    sudo pip3 install ros-introspect



## The `Package` Class

A `Package` is a path where the `$PATH/package.xml` exists and a collection of `PackageFile`s that are contained within that folder.

Each of the package files are a subtype of `PackageFile` based on their functionality, with each of the subtypes being defined in `ros_introspect.components`, including...

 * `package.xml`
 * `CMakeLists.txt`
 * Source code (Python or C++)
 * ROS Interfaces, i.e. messages, services and actions
 * DynamicReconfig configurations (ROS 1 only)
 * Plugin XML, for use with `pluginlib`
 * Launch files, both `XML` (ROS 1) and Python (ROS 2)
 * Parameter files (`.yaml`)
 * RViz configurations (`.rviz`)
 * Robot model files (`.urdf` and `.xacro`)
 * `setup.py` and `setup.cfg` for Python code
 * Documentation (Markdown, RST, licenses, etc.)
 * Miscellaneous Config files (various metadata like the `.github` folder)

Everything that does not fall into one of those categories ends up as "Other"**

**Excluding `.pyc`, `*~`, and `.git/` files
statjax 0.0.8
Data science tools built with a Jax backend.
Requires Python: >=3.11

# statjax

This library is my attempt to compile the data science tools that I use day-to-day in a single place while maintaining my coding ability and checking my understanding of various models by implementing them.

 It consists of a handful of causal estimators and a flexible linear model framework. The main convenience feature over Scikit-Learn or Statsmodels is a port of the Python Stargazer package that can produce latex tables displaying any of the linear models in the package side-by-side. The backend of the package is written in Jax and Oryx. Overhead is higher, but the package can outperform other data science libraries in large-sample or high-dimensional cases. 

The probabilistic GLM framework in the package is designed to be very modular, capable of defining GLMS in terms of a passed link function and error distribution. There are two GLM extensions that are potentially novel to Python. The first is elastic net regularization based on Glmnet in R, and the second is the ability to easily generate Bayesian linear models defined by a link function, error distribution, and prior distribution in a more standard API than that offered by PyMC3. The novelty comes from the flexibility of Oryx: rather than restricting the models to a pre-determined family of distributions, any Oryx distribution, including user-defined, can be passed for any of the distribution arguments. Similarly, any user-defined link function can be used to initialize the model, and this flexibility doesn't compromise the simplicity of the API. 

See the demo.ipynb for a full demonstration of the packages functionality.

While the models don't directly support R-style formulas as arguments, all are natively compatible with Formulaic model matrices. Initializing the design matrix using Formulaic then passing those matrices into a Statjax model duplicates the R functionality of passing a formula as model argument at the cost of a single additional line of code. The model will then automatically apply the formula of the design matrix used to fit the model in predict/score/similar functions on dataframe inputs and prevent the user from passing model matrices with different formulas to minimize headaches when iterating on formulas.