semvec/pypi-packages huggingface dataset:
pyupdater-http 0.7.0
PyUpdater Plugin: HTTP upload support
Requires Python: >=3.7
Keywords: pyupdater,pyupdater-plugin,http

[![Build Status](https://img.shields.io/github/workflow/status/micro-fan/pyupdater-http/main)](https://github.com/micro-fan/pyupdater-http/actions)
[![PyPi version](https://img.shields.io/pypi/v/pyupdater-http.svg)](https://pypi.python.org/pypi/pyupdater-http)


## Parameters

* `server_url` - add basic auth if you need it
* `data_params` - additional params that will be passed with file
* `filename_param` - field name for file name if your server need it


## Usage Example

### with `codeskyblue/gohttpserver`


Traefik is optional, you can export direct ports. This is just reminder of how we're doing it

```bash
$ pip install --user -U dot-tools
$ exec zsh

# if you have local packages in your `PATH`
# like: `/home/user/.local/bin/traefik_run`

$ traefik_run up -d
```

Then launch your web site

```yaml
version: '3.9'

services:
  releases_server:
    image: codeskyblue/gohttpserver:1.1.0
    container_name: releases_server
    # define only if you want to have basic-auth
    command: --auth-type http --auth-http basic_auth_user:basic_auth_password
    volumes:
      - ./uploads:/app/public
    # you can export ports if you're not using traefik
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.releases.rule=Host(`releases.example.com`)"
      - "traefik.http.routers.releases.entrypoints=web"

```

And put into `uploads` directory file `.ghs.yaml`:

```yaml
---
upload: false
delete: false
users:
- email: "cybergrind@example.com"
  delete: true
  upload: true
  token: auth_token_for_upload
```

And add configuration in your `config.pyu`

```json
{
 "app_config": {
    "PLUGIN_CONFIGS": {
      "httpuploader-@cybergrind": {
        "server_url": "http://basic_auth_user:basic_auth_password@releases.example.com/",
        "data_params": {
          "token": "auth_token_for_upload"
        },
        "timeout": 600,
        "filename_param": "filename"
      }
    }
  }
}
```
aegir 1.0.2
A minimal package to support configuration files without any additional work.
Requires Python: >=3.8

# Aegir

Aegir is a library allowing you to add configuration options to your Python project without any additional work.

# Usage

This system articulates around configuration entries, being class that have attributes that can be automatically overridden by a configuration file.

Here is an example of a configuration entry:

```python
# file: my_app/example.py
from aegir import ConfigEntry

class MyEntry(ConfigEntry):
    my_str: str = "default_value"
    my_int: int = 42
```

You are able to access those attributes normally:

```python
>>> from my_app.example import MyEntry
>>> MyEntry.my_str
"default_value"
>>> MyEntry.my_int
42
```

You are now also able to load a configuration file, using the `load()` function. This function will override entries based on the dotted path to the module of the entry.

Using the example above, the configuration file could look like:
```yaml
# file: my_config.yaml
my_app.example:
  my_str: "new_value"
```

The `load()` function will replace those attributes with the ones from the configuration file.

```python
>>> from aegir import load
>>> load("my_config.yaml")
>>> from my_app.example import MyEntry
>>> MyEntry.my_str
"new_value"
```

## Changing the default path

If you do not wish to use the module path, but rather a custom one, you can use the `path` metaclass argument when creating your instance.

```python
class MyEntry(ConfigEntry, path="custom.path"):
    ...
```

The entry will now be treated as if it was in the `custom.path` module.

## Default arguments

It is possible to not provide default arguements to your configuration entry.

```python
class MyEntry(ConfigEntry):
    without_default: str
```

If the configuration file does not contain the attribute, the `ConfigurationKeyError` exception will be raised. This is useful if you want to make sure that a configuration entry is always present. 

Bear in mind that the configuration file must be loaded before the module containing the entry is created. You can bypass that restriction using the `check_attributes` metaclass argument, such as:

```python
class MyEntry(ConfigEntry, check_attributes=False):
    without_default: str
```

If you wish, you are still able to call `check_attributes()` manually later on to trigger that check.

## !REF constructors

You can use this constructor inside your configuration file to reference another attributes:
```yaml
my_app.example:
  my_str: !REF my_other_entry.my_str
```

# API documentation

For more details about the API, and some other interfaces not listed in this document, please see [the full documentation](https://aegir-config.readthedocs.io/en/latest/index.html).

# Installation

The package is available on PyPI under the name [`aegir`](https://pypi.org/project/aegir/).

```
$ pip install aegir
$ poetry add aegir
$ pipenv install aegir
```

# Contributing

If you would like to join, please join [our Discord server](https://discord.akarys.me) and introduce yourself in `#aegir`. Thank you for your interest in our project!
weaver-pytorch-rnx0dvmdxk 0.0.4
Small utilities for PyTorch
Requires Python: >=3.8

# Weaver PyTorch 🧶🧵

```python
from weaver import get_classifier, get_optimizer, get_scheduler, get_transforms
from torchvision.transforms import Compose
model = get_classifier('torchvision', 'resnet50')
optim = get_optimizer(model.parameters(), name='SGD', lr=1e-3)
sched = get_scheduler(optim, name='CosineAnnealingLR', T_max=10)
transform = Compose(get_transforms([
    {'name': 'RandAugment', 'num_ops': 2, 'magnitude': 10},
    {"name": "ToTensor"},
    {"name": "Normalize", "mean": "cifar10", "std": "cifar10"}
]))
```

## Install
```bash
pip install weaver-pytorch-rnx0dvmdxk
```

---------------------------------------

## API
### get_classifier(src, name, **kwargs)
- weaver: `wide_resnet{depth}_{width}`, `preact_resnet{depth}`
- torchvision: https://pytorch.org/vision/stable/models.html

### get_optimizer(params, name, **kwargs)
- PyTorch: https://pytorch.org/docs/stable/optim.html#algorithms
- AdaBelief: https://github.com/juntang-zhuang/Adabelief-Optimizer

### get_scheduler(optim, name, **kwargs)
- PyTorch: https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate
- Custom: `HalfCosineAnnealingLR`

### get_transform(name, **kwargs)
- PyTorch: https://pytorch.org/vision/stable/transforms.html
- Custom: `AllRandAugment`, `Cutout`, `Contain`

### get_transforms(kwargs_list)
- get list of transforms

### Others
- `weaver.optimizers.exclude_wd(module: Module, skip_list=['bias', 'bn'])`
- `weaver.optimizers.EMAModel(model: Module, alpha: float)`
- `weaver.datasets.IndexedDataset`
- `weaver.datasets.RandomSubset`
cpp-containers 0.1
Python wrapper for CPP stdlib containers
Requires Python: >=3.6

# cpp-containers-python

Python wrapper for the C++ Standard Library containers. The behaviour of the containers might not be as expected, since for sorting and hashing the items only the pointer to the Python object is used, and not the actual content. That means items in ordered collections will be ordered according to memory layout and to object content. Furhermore, equality checks will work as pairwise `is` tests, because only the pointers are compared internally. Also certain operations will lead to *undefined behavior*, such as accessing out of bounds indices in `Vector`.

This design decision was made for performance reasons and to keep the code as simple and close to C++ as possible. Real equality checks can still be implemented by pairwise comparison of the objects at Python level. This won't be any faster than doing so on normal Python collections.

For more documentation about the C++ containers see <https://en.cppreference.com/w/cpp/container>.

## Install
`pip install cpp-containers` (not working yet)