semvec/pypi-packages huggingface dataset:
abc-delegation 0.3.1
A tool for automated delegation with abstract base classes
License: MIT
Requires Python: >=3.6,<4.0
Keywords: decorator,delegation,ABC,abstract-base-class,metaclasses,utility

# abc-delegation

[![Codeship Status for monomonedula/abc-delegation](https://app.codeship.com/projects/5be7b410-92cb-0138-678c-1680fac8559a/status?branch=master)](https://app.codeship.com/projects/400234)
[![codecov](https://codecov.io/gh/monomonedula/abc-delegation/branch/master/graph/badge.svg)](https://codecov.io/gh/monomonedula/abc-delegation)
[![PyPI version](https://badge.fury.io/py/abc-delegation.svg)](https://badge.fury.io/py/abc-delegation)

A tool for automated delegation with abstract base classes.

This metaclass enables creation of delegating classes 
inheriting from an abstract base class. 

This technique is impossible with regular `__getattr__` approach for delegation,
so normally, you would have to define every delegated method explicitly.
Not any more

The metaclasses also enable optional validation of the delegate attributes
to ensure they have all of the methods required by the parent object.

### Installation:
`pip install abc-delegation`


### Basic usage:
```python    
from abc import ABCMeta

from abc_delegation import delegation_metaclass

class A(metaclass=ABCMeta):
    @abstractmethod
    def bar(self):
        pass

    @abstractmethod
    def foo(self):
        pass

class B:
    def bar(self):
        return "B bar"

    def foo(self):
        return "B foo"

class C(A, metaclass=delegation_metaclass("my_delegate")):
    def __init__(self, b):
        self.my_delegate = b

    def foo(self):
        return "C foo"

c = C(B())
assert c.foo() == "C foo"
assert c.bar() == "B bar"
```

### Validation
```python
class A(metaclass=ABCMeta):
    @abstractmethod
    def bar(self):
        pass

    @abstractmethod
    def foo(self):
        pass

class B:
    pass

# validation is on by default
class C(A, metaclass=delegation_metaclass("_delegate")):
    def __init__(self, b):
        self._delegate = b

    def foo(self):
        return "C foo"

C(B())
# Trying to instantiate C class with B delegate which is missing 'bar' method
# Validation raises an error:
# TypeError: Can't instantiate bar: missing attribute bar in the delegate attribute _delegate
```


### Multiple delegates:
```python
from abc import ABCMeta

from abc_delegation import multi_delegation_metaclass


class A(metaclass=ABCMeta):
    @abstractmethod
    def bar(self):
        pass

    @abstractmethod
    def foo(self):
        pass

    @abstractmethod
    def baz(self):
        pass

class B:
    def bar(self):
        return "B bar"

    def foo(self):
        return "B foo"

class X:
    def baz(self):
        return "X baz"

class C(A, metaclass=multi_delegation_metaclass("_delegate1", "_delegate2")):
    def __init__(self, d1, d2):
        self._delegate1 = d1
        self._delegate2 = d2

    def foo(self):
        return "C foo"

c = C(B(), X())
assert c.bar() == "B bar"
assert c.foo() == "C foo"
assert c.baz() == "X baz"
```

Please refer to the unit tests for more examples.
BODtoJSON 0.0.7
Converts Infor QAGIS BODs to  flattened JSON
License: MIT
Requires Python: >=3.0

# Mapper

Mapper is a python library to convert the Infor OAGIS BODs to Flattened JSON.
The library simplifies the converted JSON by keeping only the content within DataArea.
The library will remove the Verb node from DataArea and keeps only the Noun node.

#### Usage

##### Getting it
To download BODtoJSON, either fork this github repo or simply use Pypi via pip.
```python
$ pip install BODtoJSON==0.0.7
```
##### Using it:
```python
from BODtoJSON.BODtoJSON import convert
output_var = convert(bodxml, verb)
```

#### MIT License
Read License.txt

#### GITHUB
Fork me on github https://github.com/thekakodkar/Mapper
indic-nlp-datasets 0.1.2
Indic NLP dataset loader
License: MIT
Requires Python: >=3.6

## Overview
This library provides Indian regional language datasets in an easy to use sklearn.dataset API format. You are free to use it in an application intended for commercial uses. 

![indic-nlp-datasets](https://github.com/rahul1990gupta/indic-nlp-datasets/workflows/build/badge.svg)
[![Coverage](https://img.shields.io/codecov/c/github/rahul1990gupta/indic-nlp-datasets.svg?style=flat-square)](https://codecov.io/github/rahul1990gupta/indic-nlp-datasets?branch=master)

## Installation 
You can use `pip` to install this library 

```bash
pip install indic-nlp-datasets
```
To install the latest version of the datasets, use 
```bash 
pip install git+https://github.com/rahul1990gupta/indic-nlp-datasets.git@master
```

## Datasets Available
These are the datasets available in the library

Name | Size | submodule| language
 :-- | :---| :-----|:----
Wikipedia| 275 MB| `load_wikipedia`| hi
Oscar Common Crawl| 17 GB| `load_occ`| hi
News Crawl| 472 MB| `load_news_crawl`| hi
Monlingual | 2.45 GB| `load_monolingual`| hi
Tweet Corpus | 875 MB| `load_tweets`| hi
Hinglish Corpus | 18 MB| `load_hinglish`| hi
Devdas| 300 KB | `load_devdas`| hi



## Getting started
After installation, you can start by importing the dataset 
```python
from idatasets import load_devdas
devdas = load_devdas()
print(devdas.desc) # prints description of the data
print(devdas.created_at) # date/year when dataset was created
for sent in devdas.data:
    # process text chunks
```
spys1proxy 0.0.2
Get proxy list from http://spys.one/free-proxy-list/
License: MIT
Requires Python: >=3.7
Keywords: Proxy,FreeProxy

# How to use spys one proxy list


```   
    loop = asyncio.get_event_loop()
    spys = Spys()
    spys.countries.append('DE')
    loop.run_until_complete(spys.search())
    print(spys, spys.proxy_list)
```
taguchimethod 0.0.1.0
Taguchi Method
License: MIT
Keywords: best_levels

This library is used to find best level of control factors using taguchi method.
Two things you need to use this library. First you have to select which array you want to use. I have given my github link.
There you wil see different orthogonal arrays csv file. You have to select your choise load this csv file into pandas dataframe.
second thing you need is your experimental results which you get from experiments by conducting them according to your selected array.
(For reference I have given "result.csv" file of "thickness of aluminium layer on silicon wafers" in github link.This result get from experiments conducted according to
L16 (2^15) array)
Then you have to load this csv file as pandas dataframe.

for example,
your selected array csv file name is "L16 (2^15).csv" and
results csv file is "result.csv"||
number of levels in your array used are "2"||
column number corresponding to your control factor is "1"||
then your code will be ||
from taguchimethod import getresults_levelwise ||
data=pd.read_csv("L16 (2^15).csv") ||
results=pd.read_csv("result.csv") ||
getresults_levelwise(data,1,2,results)||
we wil get results levelwise||
if output is [0.866 1.26] then it means if you use level "1" for your selected control factor then you will get result 0.866 and for level "2"
yuo will get 1.26||
github_link=https://github.com/akashsathe ||
medium link=https://medium.com/@akashsathe79 ||
I am going to publish a article about this method on medium.

Change Log
==========

0.0.2 (21/08/2020)
-------------------
- First Release