semvec/pypi-packages huggingface dataset:
InterfaceTools 1.0.7
allows for @interface class partail behavoiur decorator
Requires Python: >=3.11

# Interface Decorator

allows the use of the @Interface class decorator, which allows for partial interface behavior currently only preventing direct instantiation. 
future features hope to include method detection and force children implementations, however, this can be accomplished with the ABC package.

this package is designed to be light weight and extremely simple to use. one @ to rule them all. in this case, enforcing typical interface behaviors with good readability.


install
 windows
```cli
pip install InterfaceTools
```

Mac
```cli
pip3 install InterfaceTools
```

## Instructions:

above any classes you wish to become an interface and restrict instantaition to only children: 

```Python
from Leviathan.interface import Interface

@interface
class MyClass():

    def Method():pass
```

that is all there is to it. this decorator then restricts this class never to instantiate on its own; meaning the following:

```Python
foo = MyClass()
```
which gives the following error:

```
InterfaceInstancingError: The class MyClass is an interface. Interfaces cannot be instantiated.
```

Additionally, unlike interfaces in C# or Java, you are not required to implement their methods. however, if you desire that functionality you can use this with the ABC package to enforce children-overriding methods 

example:

```python
from abc import ABCMeta, abstractmethod

@Interface 
class myClass(metaclass=ABCMeta):
    
    @abstractmethod
    def method():pass
```

the example above will give you a full C# or Java-like interface.


other things you can do with this module are interface inheritance:


example:

```python
@Interface 
class myClass():
    pass
@Interface
class class2(myClass):
    pass
```

which you can also inherit from regular classes as well.

```python
class myClass():
    pass
@Interface
class class2(myClass):
    pass
```

the interface wrapper is fully compatible with all the default Python functions, and the ABC package for further control over your interface.
danker 0.8.1
Compute PageRank on large graphs with off-the-shelf hardware.
Requires Python: >=3.8

# danker - Compute PageRank on large graphs with off-the-shelf hardware.
 
* Standalone with any input graph:
   ```
   $ pip install danker
   $ python -m danker -h
      usage: python -m danker [-h] [-r RIGHT_SORTED] [-p OUTPUT_PRECISION] [-i]
                              left_sorted damping iterations start_value

      danker - Compute PageRank on large graphs with off-the-shelf hardware.

      positional arguments:
        left_sorted           A two-column, tab-separated file sorted by the left
                              column.
        damping               PageRank damping factor(between 0 and 1).
        iterations            Number of PageRank iterations (>0).
        start_value           PageRank starting value (>0).

      optional arguments:
        -h, --help            show this help message and exit
        -r RIGHT_SORTED, --right_sorted RIGHT_SORTED
                              The same file as left_sorted but sorted by the right
                              column.
        -p OUTPUT_PRECISION, --output_precision OUTPUT_PRECISION
                              Number of places after the decimal point.
        -i, --int_only        All nodes are integers (flag)

   $ wget https://raw.githubusercontent.com/athalhammer/danker/master/test/graphs/test.links
   $ python3 -m danker test.links 0.85 30 1
      1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.
      Computation of PageRank on 'test.links' with danker took 0.00 seconds.
      C	3.18985350447380434
      B	3.55722134157057246
      A	0.30410528185694391
      D	0.36260066319290651
      F	0.36260066319290651
      E	0.75035528185694389
      G	0.15000000000000002
      H	0.15000000000000002
      I	0.15000000000000002
      K	0.15000000000000002
      L	0.15000000000000002
   ```

* As Python library for computing PageRank on large graphs:
   ```
   $ pip install danker
   $ python
   >>> import danker
   ```
   More information on this option can be found at https://danker.rtfd.org.

More information on the project: [Compute PageRank on the Wikipedia graph](https://github.com/athalhammer/danker)
simplebuilder 0.4.0
Simple build script for packages
Requires Python: >=3.8
Keywords: build

# simplebuilder

Build README for PyPI from Github README

## Usage

This project is used and will be used by [WebtoonScraper](https://github.com/ilotoki0804/WebtoonScraper) and many other packages.

Relative links and images will be converted and additional message will be shown on top of PyPI description.

## Changelog

* **0.4.0**: Change concept of package
* **0.3.0**: Change only explicit relative path link
* **0.2.0**: Initial version