semvec/pypi-packages huggingface dataset:
pyexpose 0.1.3
Python library for creating SSH-based tunnels to expose local services, supporting providers such as serveo.net and localhost.run. It embraces modern Python syntax, asyncio, and context managers for a straightforward and user-friendly experience.
License: MIT
Requires Python: >=3.8

# pyexpose
[![Documentation Status](https://readthedocs.org/projects/pyexpose/badge/?version=latest)](https://pyexpose.readthedocs.io/en/latest/?badge=latest)

pyexpose is a Python library designed to streamline the process of exposing local services to the internet using various SSH-based providers, such as serveo.net and localhost.run. With pyexpose, developers can effortlessly share their local services with remote collaborators or external systems, eliminating the need for manual configuration and exposing an abstraction layer for seamless integration.

## Installation

Install the `pyexpose` package with [pip](https://pypi.org/project/pyexpose):

```console
$ pip install pyexpose
```

Or install the latest package directly from GitHub with the async extra:

```console
$ pip install git+https://github.com/hari01584/pyexpose
```

## Example Usage
```python
import asyncio
import threading
from http.server import ThreadingHTTPServer
from http.server import SimpleHTTPRequestHandler

class MyHttpRequestHandler(SimpleHTTPRequestHandler):
    def end_headers(self):
        self.send_header('Access-Control-Allow-Origin', '*')
        SimpleHTTPRequestHandler.end_headers(self)

    def do_GET(self):
        self.send_response(200)
        self.send_header("Content-type", "text/html")
        self.end_headers()
        html = f"31"  # how do I modify this line to serve files?
        self.wfile.write(bytes(html, "utf8"))

http_server = ThreadingHTTPServer(("0.0.0.0", 4457), MyHttpRequestHandler)
http_server_thread = threading.Thread(target=http_server.serve_forever)
http_server_thread.daemon = True
http_server_thread.start()

async def start_tunnel():
    from pyexpose.providers.localhost_run import LocalRunConnector
    connector = LocalRunConnector()
    async with connector.connect() as session:
        async with session.tunnel(4457) as tunnel:
            print("Started tunnel, You can access your local server at: ", tunnel.ip)
            await asyncio.sleep(100000)

asyncio.run(start_tunnel())
```

Please look into official docs for more information - https://pyexpose.readthedocs.io/en/latest/
format4me 0.0.3
A library to easily format the response coming from your bard or any other ai agent .
License: MIT
Keywords: responseFormatter,chatgpt,bard

This is library to format your bard  or other ai agent response. 

How to use? : https://github.com/s2ahil/format4me

usage :

from format4me import format_content

print(format_content('### Key Concepts * **Blockchain** is a shared, immutable ledger that facilitates the process of recording transactions and tracking assets in a business network. * **Blockchain is important** because it provides immediate, shared and completely transparent information stored on an immutable ledger that can be accessed only by permissioned network members. * **A blockchain network can track** orders, payments, accounts, production and much more. * **With blockchain,** as a member of a members-only network, you can rest assured that you are receiving accurate and timely data, and that your confidential blockchain records will be shared only with network members to whom you have specifically granted access. * **Blockchain creates trust** because it represents a shared record of the truth. * **Types of blockchain networks** include public, private, and consortium blockchains. * **Bitcoin** is an unregulated, digital currency that uses blockchain technology as its transaction ledger. * **The IBM Blockchain Platform** is powered by Hyperledger technology and is optimized to deploy on Red HatÂ® OpenShiftÂ®. * **To learn more about blockchain,** visit the IBM Blockchain website or read the IBM Blockchain for Dummies book.'))

Change Log
==========

0.0.1(23/1/2023)
-----------------
- First Release


0.0.2(23/1/2023)
-----------------
- First Release

0.0.3(28/1/2023)
-----------------
- Third stable  Release
tucker-riemopt 1.0.1
Tucker toolbox for Riemannian optimization.
License: MIT
Requires Python: >=3.9,<4.0

# Tucker Riemopt

Python implementation of the Tucker toolbox. Package allows users to manipulate
tensors in Tucker and SF-Tucker [[1]]() formats. It also provides tools 
for implementing first-order optimization methods of the Riemannian 
optimization on the manifolds of tensors of fixed Tucker rank or fixed SF-Tucker rank.
For instance, package implements a method for efficiently computing the Riemannian
gradient of any smooth function via automatic differentiation.

The library is compatible with several computation frameworks, such as PyTorch and
JAX, and can be easily integrated with other frameworks.

## Installation
NumPy, SciPy and [opt-einsum](https://pypi.org/project/opt-einsum/)
are required for installation. Additionally, you need to install your special
computation framework: PyTorch or JAX.

Package may be installed using

`pip install tucker_riemopt[torch/jax]`

with corresponding computation framework.

## Use cases
See [this repository](https://github.com/johanDDC/R-TuckER) for examples of package usage.

Default computation framework is PyTorch. For using JAX you should

1. Install JAX;
2. Enable JAX backend using

```python
from tucker_riemopt import set_backend
set_backend("jax")
```

<!-- ## Quick start
See `examples` folder to dive into `tucker_riemopt` basics.

* [backend](https://github.com/johanDDC/tucker_riemopt/blob/master/examples/backend.ipynb) notebook contains a guide, how to use different computational frameworks for both routine operations and computations requires autodiff;
* [eigenvalues](https://github.com/johanDDC/tucker_riemopt/blob/master/examples/eigenvalues.ipynb) notebook contains a basic guide for performing riemannian optimization on manifold of tensors of fixed multilinear rank using this package; -->

[//]: # (## Structure overview)

[//]: # ()
[//]: # (The main classes representing Tucker tensors and Tucker matrices are [`Tucker`]&#40;https://github.com/johanDDC/tucker_riemopt/blob/master/tucker_riemopt/tucker.py&#41; and [`TuckerMatrix`]&#40;https://github.com/johanDDC/tucker_riemopt/blob/master/tucker_riemopt/matrix.py&#41;. )

[//]: # (Also we've implemented [`SparseTucker`]&#40;https://github.com/johanDDC/tucker_riemopt/blob/master/tucker_riemopt/tucker.py&#41; class for sparse representation of Tucker tensor. May be useful for tensor completion task or RecSys.)

## Documentation

Detailed information may be found [here](https://johanddc.github.io/tucker_riemopt/).

## License
MIT License