semvec/pypi-packages huggingface dataset:
senseiv2test-aliFrancis 1.0
Sensor Independent Cloud and Shadow Masking with Partial Labels and Multimodal Inputs
Requires Python: >=3.9

# SEnSeIv2
Sensor Independent Cloud and Shadow Masking with Ambiguous Labels and Multimodal Inputs


## Installation

Before installing SEnSeIv2 with either method below, make sure you have a working installation of PyTorch and torchvision (with CUDA drivers, if you want to use a GPU). [More info on install pytorch here here](https://pytorch.org/get-started/locally/). This is _not included_ in the requirements.txt file. 

#### Install with pip


To install SEnSeIv2 as both a python package and a command line tool:

```
pip install senseiv2
```

This will download the default model weights from the [SEnSeIv2 HuggingFace model repo](https://huggingface.co/aliFrancis/SEnSeIv2). Other model weights used in the paper can also be found here, if you are interested.

#### Source code

If you would like to train models yourself, or use or adapt the code, you can clone this repository.

```
git clone git@github.com:aliFrancis/SEnSeIv2.git
cd ./SEnSeIv2
python setup.py install
```

## Basic Usage

#### Command line interface

As an example, you can produce a cloud mask (with classes _clear_, _thin_, _thick_ and _cloud shadow_) for a Sentinel-2 scene

```
senseiv2 -v sentinel2 <path/to/S2-scene.SAFE> <path/to/output.tif>
```
Or, for Landsat 8 or 9:
```
senseiv2 -v landsat89 <path/to/landsat89-scene> <path/to/output.tif>
```

To see all options for the command line tool, which, for instance, allow you to control parameters such as the class structure of the mask, or its resolution, you can use:

```
senseiv2 --help
```

#### Importing in python

You can use the cloud masks within python, if you are doing your own data preprocessing, or want to customise things in other ways. A typical use-case might begin with:

```python
from senseiv2.inference import CloudMask
from senseiv2.utils import get_model_files

scene = ... # Some numpy array representing a satellite image
descriptors = [
  {...},    # See samples/ for examples of descriptor dictionaries
  {...}
]

# Pick pre-trained model from https://huggingface.co/aliFrancis/SEnSeIv2
model_name = 'SEnSeIv2-SegFormerB2-alldata-ambiguous'
config, weights = get_model_files(model_name)

# Lots of options in the kwargs for different settings
cm = CloudMask(config, weights, descriptors=descriptors,verbose=True)

mask = cm(scene)
```

#### Advanced uses (model training etc.)

It is not easy to replicate precisely the training strategy used here, because it is not possible to redistribute all the datasets used. However, the train.py script is included, along with some sample data in samples/ to get you started. All the data used has been preprocessed into a shared format using the [eo4ai tool](https://github.com/ESA-PhiLab/eo4ai).

After collecting some of the datasets, you can use the training script with a config file (with some modifications) from [the HuggingFace repo](https://huggingface.co/aliFrancis/SEnSeIv2):

```
python train.py path/to/config.yaml
```
xiomedon 1.0.2
Library to call Open AI gpt3.5t-turbo and collect reponses and check for Accuracy
Requires Python: >=3.7

# xiomedon

Library to call Open AI gpt3.5t-turbo and collect reponses and check for Accuracy

## Features

- `v0.0.1` Call Open AI gpt3.5 and fetch respones

## Installation

1. Download and install the latest version of [python](https://www.python.org/downloads/). Open a terminal and check that it is installed.

   Windows
   ```
   py --version
   ```

   Linux/MAC OS
   ```
   python3 --version
   ```

2. Make sure you have upgraded version of pip.

   Windows
   ```
   py -m pip install --upgrade pip
   ```

   Linux/MAC OS
   ```
   python3 -m pip install --upgrade pip
   ```

3. Install xiomedon using pip.

   Windows
   ```
   pip install xiomedon
   ```

   Linux/MAC OS
   ```
   python3 -m pip install xiomedon
   ```

4. Check that the package was installed

   ```
   pip show xiomedon
   ```

## Usage


   ```
   import os
   import xiomedon as x

   # Set your OpenAI API key
   os.environ["OPENAI_API_KEY"] = "your-openai-key"

   # 'xiomedon` provides a function `invoke_openai` caling gpt3.5 turbo  and returns string with response
   response = x.invoke_openai("what is the capital of Austria?")
   print(response)

   ```
itwingstestsproject 0.1
A small example package
Requires Python: >=3.6


# Make sure you have upgraded version of pip
Windows
```
py -m pip install --upgrade pip
```

Linux/MAC OS
```
python3 -m pip install --upgrade pip
```

## Create a project with the following structure
```
packaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── setup.cfg
├── src/
│   └── example_package/
│       ├── __init__.py
│       └── example.py
└── tests/
touch LICENSE
touch pyproject.toml
touch setup.cfg
mkdir src/mypackage
touch src/mypackage/__init__.py
touch src/mypackage/main.py
mkdir tests
```

## pyproject.toml 

This file tells tools like pip and build how to create your project

```
[build-system]
requires = [
    "setuptools>=42",
    "wheel"
]
build-backend = "setuptools.build_meta"
```
build-system.requires gives a list of packages that are needed to build your package. Listing something here will only make it available during the build, not after it is installed.

build-system.build-backend is the name of Python object that will be used to perform the build. If you were to use a different build system, such as flit or poetry, those would go here, and the configuration details would be completely different than the setuptools configuration described below.


# Setup.cfg setup
Using setup.cfg is a best practice, but you could have a dynamic setup file using setup.py

```
[metadata]
name = example-pkg-YOUR-USERNAME-HERE
version = 0.0.1
author = Example Author
author_email = author@example.com
description = A small example package
long_description = file: README.md
long_description_content_type = text/markdown
url = https://github.com/pypa/sampleproject
project_urls =
    Bug Tracker = https://github.com/pypa/sampleproject/issues
classifiers =
    Programming Language :: Python :: 3
    License :: OSI Approved :: MIT License
    Operating System :: OS Independent

[options]
package_dir =
    = src
packages = find:
python_requires = >=3.6

[options.packages.find]
where = src

```
# Running the build
### Make sure your build tool is up to date
Windows
```
py -m pip install --upgrade build
```
Linux/MAC OS
```
python3 -m pip install --upgrade build
```


### Create the build
```
py -m build
```













### References
https://packaging.python.org/tutorials/packaging-projects/
hedera-proto 0.49.1
Hedera Protobufs
Requires Python: >=3.8

# hedera-protobufs-python

Hedera API Definitions in Protocol Buffer compiled to Python

They are compiled from .proto files in [Java Protobufs](https://github.com/hashgraph/hedera-protobufs-java).

## Usage

Install:

    pip install hedera-proto

To use, just import them in your python program, e.g.:

    from hedera_proto import AccountID
    accountId = AccountID()

Or:

    import hedera_proto as proto
    accountId = proto.AccountID()

## Note

This is used by pure Python Hedera SDK, which, as of now (2021/11), has not been released yet.

You are encouraged to use the fully functional Python SDK [github.com/wensheng/hedera-sdk-py](https://github.com/wensheng/hedera-sdk-py), which is a Python wrapper around Java SDK, while waiting for pure Python SDK.