semvec/pypi-packages huggingface dataset:
CombiCSP 1.5.0
A package for Concentrated Solar Collectors and Solar Tower Calculations
Requires Python: >=3.8

# Combi_CSP
CombiCSP is an open source software for dynamic modelling of concentrating solar energy power plants. CombiCSP utilizes solar resource, system engineering inputs as well as financial tools to provide dynamic simulations and annual yields of concentrating solar power plants. It readily provides modelling of plants based on solar power tower and parabolic trough collectors and it can be extended to novel solar energy modeling approaches and analyses as needed.

The relevant work pertaining to this software is : https://doi.org/10.1016/j.apenergy.2022.119450


# Quick-Start

clone the repository from [the CombiCSP][1].

then move to the root of the repository and perform (this requires python [`setuptools`][1] )

`python setup.py install`

The setup should take care of all problems.

The `Combi_CSP_oop.ipynb` describes a typical use scenario.

Additionally, example cases are scripted in the following files:

- `CSPCret.py`: heliostat and CSP power and energy outputs in a location in Crete, Greece
- `CSP50Compare.py`: Combined heliostat and CSP power and energy outputs in a location in Crete, Greece

# installation/setup

## requirements

The following **mainstream** packages are required for this library (most of them are already installed in a typical installation).

- matplotlib
- scipy
- pandas
- ipykernel

Additional libraries are:

- pvlib_python
- iapws (The InternationalAssociation for the Properties of Water and Steam)
- numpy-financial

## Conda installation

The following describes a minimum environment using conda. 

(Optional) Preferably create a new environment for the packages

`conda create -n combicsp python=3`

installation requires:

- matplotlib
- scipy
- pandas
- ipykernel

`conda install matplotlib scipy pandas ipykernel`

- pvlib_python:

`conda install -c conda-forge pvlib-python`

- iapws: The InternationalAssociation for the Properties of Water and Steam

`conda install -c conda-forge iapws`

- numpy-financial

`conda install -c conda-forge numpy-financial`

# Developers

- G. E. Arnaoutakis: Technical direction, and original calculation functions
- N. Papadakis: Software Design, Package Maintenance.


# TODO

See [history.md](history.md)

[1]: https://pypi.org/project/setuptools/
[2]: https://github.com/npapnet/Combi_CSP.git
bastionai 0.2.1
Client SDK for BastionAI Confidential AI Training.
Keywords: confidential computing training client enclave amd-sev machine learning

# BastionAI Client

BastionAI Client is a python library to create client applications for BastionAI Server (Mithril Security's confidential training server). 

**If you wish to know more about BastionAI, please have a look to the project [Github repository](https://github.com/mithril-security/bastionai/).**

## Installation

### Using pip
```bash
$ pip install bastionai
```

### Local installation
**Note**: It is preferrable to install BastionAI package in a virtual environment.

Execute the following command to install BastionAI locally.
```shell
pip install -e .
```

## Usage

### Uploading a model and datasets to BastionAI
The snippet below sets up a **very simple** linear regression model and dataset to train the model with.
```python
import torch
from bastionai.utils import TensorDataset  
from torch.nn import Module
from bastionai.psg.nn import Linear  
from torch.utils.data import DataLoader

class LReg(Module):
    def __init__(self) -> None:
        super().__init__()
        self.fc1 = Linear(1, 1, 2)

    def forward(self, x: Tensor) -> Tensor:
        return self.fc1(x)

lreg_model = LReg()

X = torch.tensor([[0.0], [1.0], [0.5], [0.2]])
Y = torch.tensor([[0.0], [2.0], [1.0], [0.4]])
train_dataset = TensorDataset([X], Y)
train_dataloader = DataLoader(train_dataset, batch_size=2)

X = torch.tensor([[0.1], [-1.0]])
Y = torch.tensor([[0.2], [-2.0]])
test_dataset = TensorDataset([X], Y)
test_dataloader = DataLoader(test_dataset, batch_size=2)
```

### Training a model on BastionAI

With this snippet below, BastionAI is used to securely and remotely train the model. 

The model, along with the training and testing datasets are uploaded to BastionAI through the client API.

```python

from bastionai.client import Connection, SGD  


with Connection("localhost", 50051, default_secret=b"") as client:
    remote_dataloader = client.RemoteDataLoader(
        train_dataloader,
        test_dataloader,
        "Dummy 1D Linear Regression Dataset (param is 2)",
    )
    remote_learner = client.RemoteLearner(
        lreg_model,
        remote_dataloader,
        metric="l2",
        optimizer=SGD(lr=0.1),
        model_description="1D Linear Regression Model",
        expand=False,
    )

    remote_learner.fit(nb_epochs=100, eps=100.0)

    lreg_model = remote_learner.get_model() # Gets trained model from BastionAI server.
```


## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

## License
This project is licensed under [Apache 2.0 License.](https://github.com/mithril-security/bastionai/blob/master/LICENSE)
mimo-sms 1.0.0
MIMO SMS Gateway Python Library
Requires Python: >=3.8
Keywords: gateway,sms,mimo,integração

# mimo-sms Python

[![](https://img.shields.io/badge/mimosms-OpenSource-blue.svg)]("https://www.mimo.it.ao/pt")

Python library to integration with MIMO SMS Service.
The library is a simple integration for software developers 
to use in their projects and they need to quickly connect to an SMS service.

# Installation

``` 
pip install mimo_sms 
```

# Configuration
For configuration it is necessary to add the system environment variables, the following variables with the respective values `MIMO_SMS_TOKEN` and `MIMO_SMS_HOST`

Open terminal and do this
### Linux or Mac
```
$ export MIMO_SMS_TOKEN=your-token-key
$ export MIMO_SMS_HOST=hostname
```

### Windows

``` 
set MIMO_SMS_TOKEN=your-token-key
set MIMO_SMS_HOST=hostname
```


# Use

### New message

Send sms message

``` 
from mimo_sms.resources import Message
message_resource = Message()
message_resource.send('mysender', ['933843893'], 'Olá, Seja bem-vindo (a)') 
```


### Consulting credits
View your balance
``` 
from mimo_sms.resources import Message
message_resource = Message() 
balance = message_resource.view_credits()
print(balance)
```

### Add Credits
Add credits
``` 
from mimo_sms.resources import Message
message_resource = Message() 
voucher_code = "your-voucher-code"
message_resource.charge_credits(voucher_code)
```

### Create sender
Create a new sender
```
from mimo_sms.resources import Sender
payload = {'sender': 'your-sender-name', 'reason': 'your-reason'}
sender_resource = Sender()
sender_resource.create(**payload)
```

### List your senders
List senders requested
```
from mimo_sms.resources import Sender
payload = {'sender': 'your-sender-name', 'reason': 'your-reason'}
sender_resource = Sender()
senders_requested = sender_resource.list(requested=True)
```

List all senders available

```
from mimo_sms.resources import Sender
payload = {'sender': 'your-sender-name', 'reason': 'your-reason'}
sender_resource = Sender()
senders = sender_resource.list()
```
# Note
All other resources are accessed in the same way by importing a resource class and calling only the class's methods to interact with the resource's data.

# License

The library is available as open source under the terms of the MIT License.