semvec/pypi-packages huggingface dataset:
pythonGateway 1.1
Python wrapper for Bitocredit API
License: MIT

<h3 align="center" >Bitocredit python package</h3>
<h5>python wrapper for Bitocredit API</h5>

# usage
install package using pip
<br>
<br>
```bash
pip install pythonGateway
```

<br>
<br>

and use package like this:

```python
    from pythonGateway import BitocreditApi
    
    baseurl = "https://bitocredit.com/api/";
    token = "TOKEN"; # fill your token
    
    Api = BitocreditApi(baseurl , token);
    
    res = Api.createWallet("wallet_id" , "network")  # replace wallet_id with your wallet id and network type
    print(res)

```

# methods

- [createWallet](#createwallet)
- [transactionCheck](#transactioncheck)
- [transactionRecovery](#transactionrecovery)
- [transactionFee](#transactionfee)
- [transactionExample](#transactionexample)


# <a id="createwallet">createWallet</a>

This method used for creating wallet for user
<br>
<br>
endpoint : https://bitocredit.com/api/create/wallet/{token}
<br>
<br>

```python
    res = Api.createWallet("wallet_id" , "network")  # replace wallet_id with your wallet id and network type
    print(res)
    
```

# <a id="transactioncheck">transactionCheck</a>

This method used for check a transaction is confirmed or not
<br>
<br>
endpoint : https://bitocredit.com/api/transaction/check/{token}
<br>
<br>

```python 
    res = Api.transactionCheck("transaction_hash" , "wallet_address") # replace transaction_hash and wallet_address with your transaction hash and wallet address
    print(res)

```

# <a id="transactionrecovery">transactionRecovery</a>

This method used for check a transaction that is lost in blockchain
<br>
<br>
endpoint : https://bitocredit.com/api/transaction/recovery/{token}
<br>
<br>

```python 
    res = Api.transactionRecovery("transaction_hash")  # replace transaction_hash with your transaction hash
    print(res)

```


# <a id="transactionfee">transactionFee</a>

This method used for check a transaction that is lost in blockchain
<br>
<br>
endpoint : https://bitocredit.com/api/transaction/fee/{token}
<br>
<br>

```python
    res = Api.transactionFee()
    print(res)

```


# <a id="transactionexample">transactionExample</a>

Please only use this api for test ! it's only an example to show how the server sends data to callback after payment confirmation
<br>
<br>
endpoint : https://bitocredit.com/api/transaction/example/callback
<br>
<br>

```python 
    res = Api.transactionExample("transaction_hash") # replace transaction_hash with your transaction hash
    print(res)

```
myccli 0.1.4
Mycelium CLI
License: MIT
Requires Python: >=3.9,<4.0

Mycelium CLI
============

### What is Mycelium?

Mycelium is a framework that helps you easily write highly scalable (microservice) applications.

Mycelium automatically generates **Terraform** from your code, and handles load balancing for you.

The goal is to write your code without thinking about the infrastructure as if it was a simple monolithic application, and then have Mycelium decide on how to split your app into components, handle load balancing, communication between components, etc...

### How to use Mycelium?
Import this [runtime library](https://github.com/BizarreCake/myc) into your app and use it to annotate your code with service hints/constraints.

The more this framework evolves, the less help you will have to give in the form annotations.

Finally, invoke this CLI (`myc` command) and watch it automatically generate Terraform for you (and optionally deploy it for you).

### Example Usage

Create an empty Poetry application with `myc` (runtime) as dependency and `myccli` (compiler) as a development dependency.

Add some package (e.g. `test_app`) to your project with `__init__.py` containing:

```python
from myc import Mycelium

app = Mycelium()
foo_service = app.create_service("foo")
bar_service = app.create_service("bar")

@foo_service.fastapi.get("/")
def foo():
    return f'The answer is: {bar()}'

@bar_service.fastapi.get("/")
def bar():
    return 42
```

Then run `myc compile test_app:app` to generate Terraform, followed by `myc deploy` to deploy your app!

What will happen:
* A Dockerfile will be generated for each service
* Docker images will be built and pushed to a private ECR repository
    * *Temporary caveat*: The framework expects you to have a repository called `mycelium` in your AWS region of choice (an update will come soon to have this repo created automatically)
* Two ECS services will be created in a new cluster for `foo` and `bar` services.
* The call to `bar()` in `foo` function will be transformed to an HTTP get request!

### Limitations

This project is in its earliest stages, and feature count is limited at the moment.
The framework (currently) assumes projects to use Poetry as a package manager

#### Currently supported features:
* AWS as a cloud provider
* ECS as a platform in AWS (Lambda support will come very soon)
* Poetry as the package manager

More will come soon!

### Upcoming Features

* Dynamic and static load measurements to determine optimal load balancing strategy
* Support more cloud providers: Google Cloud, Azure, etc...
* Support more service platforms: AWS Lambda, EC2, etc...
* Support more package managers other than Poetry
* Flexible serialization/deserialization strategies
* Command to launch dashboard to watch:
    * Service topology
    * Aggregated logs
    * Load balancing metrics