semvec/pypi-packages huggingface dataset:
fandomanime 0.0.3
Simple web scraper for fandom anime summaries
Requires Python: >=3.6

# Overview
Written to scrape clean anime summaries from https://www.fandom.com/

###  Getting it

To download animefandom, either fork this github repo or simply use Pypi via pip.
```sh
$ pip install fandomanime
```

### Using it

First, 
```Python
import fandomanime as fa
```
Create an fandomanime object

```Python
faObject = fa.AnimeFandom("https://naruto.fandom.com/wiki/Konohamaru!!")
```
Now get the summary,
```Python
print(faObject.getSummary())
```

License
----

MIT License

MIT License

Copyright (c) 2020 Matthew Murray

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
vcpkgpip 1.0.0
a python wrapper for vcpkg

# vcpkgpip
a python wrapper for vcpkg

## installation
```sh
pip install vcpkgpip
```

## usage
#### bootstrap vcpkg
```sh
vcpkg-bootstrap
```
#### search for package
```sh
vcpkg search [search term]
```
#### install package
```sh
vcpkg install [packages to install]
```
spconfigreader 0.3.3
A utitlity to read config from yaml-files and environment (like Spring for Java)
Requires Python: >=3.6

# Spring Confing Reader

## Table of Contents

- [Spring Confing Reader](#spring-confing-reader)
  - [Table of Contents](#table-of-contents)
  - [General Information](#general-information)
  - [Configfile](#configfile)
  - [Function overview](#function-overview)
  - [Usage](#usage)
    - [object](#object)
    - [single entry](#single-entry)
  - [Override with Environment Vairables](#override-with-environment-vairables)

## General Information

There are several config readers for Python but no one matches my requirements. so, i created my own.

The focus is to read configuration from a YAML file with the option to override it with environment variables, which is needed for working with Docker.

Inspiration was the configuation in the Java framework Spring, which leads to the name.

## Configfile

As default, {root}/config.yml is the configfile. This can be changed with the following code before the first use.

```python
configreader.__configfile__ = "path/to/file.yml"

```

## Function overview

```python
get(key: str, default: str = None)
```

```python
getObject(obj: object, path: str = None)
```

## Usage

### object

first, create a class with all fields you want to read. They need either a type annotation or must be initialized. Subclasses must always be initalized.

The variable name should match the name in the YAML file.

At this point, default values can also be defined. If a value is given in the YAML, it will be overrwritten.

An additional field it the __path__ field, wich contains the root path in the YAML file. This can also be specified in the getObject() method later

As example:

config.yml

```yaml

datasource:
  server: "mssql.server"
  test:
    val1: "foo"
    val2: "bar"
```

code

```python
class Test:
    val1: str
    val2: str

class Datasource:
    __path__: str = "datasource"

    server: str
    port: int = 1433
    protocol: str = "tcp"
    test = Test()
```

To read the values, use the getObject() method in one of this ways:

```python
datasource = configreader.getObject(Datasource())
```

```python
datasource = Datasource()
configreader.getObject(datasource)
```

### single entry

To get only a single entry, use the get() function

```python
val = get("path.of.entry")
```

second parameter is a default value if no entry is found in the YAML file.

## Override with Environment Vairables

To override a entry in the YAML, set an environment variable with the same key but with upper letters and with _ instead of .

Example:

```bash
path.to.entry -> PATH_TO_ENTRY
```
UST-Download-Cache 2.1.0
A package for caching downloads of specially formatted files.
Requires Python: >=3.5

# USTDownloadCache
<p align="center">
	<a href="https://github.com/canonical/ust-download-cache">
		<img alt="GitHub license" src="https://img.shields.io/github/license/canonical/ust-download-cache">
	</a>
	<img src="https://img.shields.io/github/v/tag/canonical/ust-download-cache" alt="GitHub tag (latest by date)">
	<img alt="GitHub last commit" src="https://img.shields.io/github/last-commit/canonical/ust-download-cache">
</p>

## About

The USTDownloadCache is used by the Ubuntu Security Team to improve the runtime
of other packages by caching certain JSON files.

## Using USTDownloadCache

### Example:

```python
import logging
from ust_download_cache import USTDownloadCache

logger = logging.getLogger("")
download_cache = USTDownloadCache(logger)

url = "URL_GOES_HERE"
data = download_cache.get_data_from_url(url)
metadata = download_cache.get_cache_metadata_from_url(url) # used by USTDownloadCache
```

### Extracting zipped files

USTDownloadCache has the ability to download, extract, and cache either bz2 or
gz archives. These files are extracted and stored uncompressed so that the data
can be accessed as quickly as possible.

### Metadata

The USTDownloadCache relies on metadata contained within the file it is
downloading/caching. The JSON must supply a "metadata" key, which provides a
timestamp (seconds since the Unix epoch) and time to live (ttl) in seconds. The
cached version of the file is considered to be expired when `timestamp + ttl >
now`

```json
{
    "metadata": {
        "timestamp": 1591887905,
        "ttl": 3600,
        "version": "1.0"
    },
    "data": {
        "name1": "value1",
        "name2": "value2"
    }
}
```

## Installation

### From Source
To install from source, you can clone this repository and install
USTDownloadCache:

```
$> git clone https://github.com/canonical/ust-download-cache
$> pip3 install --user ./ust-download-cache/
```

### As a dependency

As USTDownloadCache is not in PyPI at the moment, you must use the github
tarball in your setup.py:

```python
install_requires = [
        "ust-download-cache @ https://github.com/canonical/ust-download-cache/archive/v1.0.1.tar.gz",
]
```

## Development

### Installing precommit hooks
To install the precommit hooks, run

    pip3 install --user pre-commit
    ~/.local/bin/pre-commit install

### Running the test suite
You can run the automated test suite by running

```
$> python3 -m pytest
```

An HTML code coverage report will be generated at `./htmlcov`. You can view
this with any web browser (e.g. `firefox ./htmlcov/index.html`).