semvec/pypi-packages huggingface dataset:
tinc-python 0.9.1
TINC python module
Requires Python: >=3.6

# TINC python module and tools

This is the python module for TINC. It can be used standalone, or in conjunction with a C++ application written with TINC to provide a TINC server:

https://github.com/AlloSphere-Research-Group/tinc

tinc-python depends on numpy, matplotlib and filelock. If ipywidgets is available, tinc-python can provide interactive widgets for the jupyter notebook.

To install additional dependencies for tinc-python:
```
pip install ipywidgets
```

# Installing jupyterlab on macOS Through homebrew
There are many ways to install jupyterlab. Here is one we have tested to work with TINC.
```
brew install jupyterlab
```

When brew installs jupyter lab and installs python3.8, it mentions it is keg only, so need to follow brew's instructions:
```
Python has been installed as /usr/local/opt/python@3.8/bin/python3
You can install Python packages with /usr/local/opt/python@3.8/bin/pip3 install <package>
They will install into the site-package directory
/usr/local/opt/python@3.8/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages
See: https://docs.brew.sh/Homebrew-and-Python
python@3.8 is keg-only, which means it was not symlinked into /usr/local,
because this is an alternate version of another formula.
If you need to have python@3.8 first in your PATH run:
echo 'export PATH="/usr/local/opt/python@3.8/bin:$PATH"' >> /Users/cannedstar/.bash_profile
For compilers to find python@3.8 you may need to set:
export LDFLAGS="-L/usr/local/opt/python@3.8/lib"
For pkg-config to find python@3.8 you may need to set:
export PKG_CONFIG_PATH="/usr/local/opt/python@3.8/lib/pkgconfig"
```

To install additional dependencies for tinc-python for the jupyter python:
```
/usr/local/opt/python@3.8/bin/pip3 install filelock matplotlib ipywidgets
```
webconnect 0.0.1
A simple tool to publish websites to RStudio Connect
Requires Python: >=3.6

# webconnect

A simple python package and command line tool to publish static websites to RStudio Connect.

This package is not affiliated with RStudio.

## Command line tool

The primary way to use webconnect is via it's cli tiil, `webconnectcli`.

THe cli tool requires 5 parameters. 

* A path to a directory containing the static site to publish
* A unique name for the content on Connect - alphanumeric and underscores only
* A "pretty" name for the content that will be displayed in the Connect UI
* The URL for the Connect instance
* The Connect API key to use


```
usage: webconnectcli [-h] -d DIR -n NAME -p PRETTY -s SERVER -k KEY

optional arguments:
  -h, --help            show this help message and exit
  -d DIR, --dir DIR     name of the directory to publish
  -n NAME, --name NAME  name of the content - alphanumeric and underscores only
  -p PRETTY, --pretty PRETTY
                        pretty name
  -s SERVER, --server SERVER
                        RStudio Connect URL
  -k KEY, --key KEY     Connect API key
```

So a full example would look something like this:

```
webconnect \
  -d path/to/site/content \
  -n static_site \
  -p "Example.org main site" \
  -s https://connect.example.org \
  -k ${CONNECT_API_KEY}
```

This relies on the Connect API key being available in the `$CONNECT_API_KET` environment variable. 
You could use the key directly if you prefer.

## Package usage

```
import webconnect
webconnect.pub_rsconnect(
    "path/to/site/content,
    "static_site",
    "Example.org main site",
    "https://connect.example.org",
    "hgjhghgjguytuyt6876uytgfhg",
)
```
pyimporters-yummy 0.1.16
Sherpa knowledge import plugins
Requires Python: >=3.8

## Requirements

- Python 3.8+
- Flit to put Python packages and modules on PyPI
- Pydantic for the data parts.

## Installation
```
pip install flit
pip install pyimporters-yummy
```

## Publish the Python Package to PyPI
- Increment the version of your package in the `__init__.py` file:
```
"""An amazing package!"""

__version__ = 'x.y.z'
```
- Publish
```
flit publish
```

## Write your own pyimporters plugin
- Git clone the pyimporters_yummy project
```
git clone git@bitbucket.org:kairntech/pyimporters_yummy.git
```
- Rename the project with your own format name <new_format>
```
mv pyimporters_yummy pyimporters_<new_format>
```
- Delete the .git directory
```
rm -r -f pyimporters_<new_format>/.git
```
- Change to the new pyimporters_<new_format> directory
```
cd pyimporters_<new_format>
```
- Rename the package directory project
```
mv pyimporters_yummy pyimporters_<new_format>
```
- Rename the python file implementation
```
mv pyimporters_<new_format>/yummy.py pyimporters_<new_format>/<new_format>.py
```
- Rename the python tests file implementation
```
mv tests/test_yummy.py tests/test_<new_format>.py
```
- Edit the pyproject.toml file to change a few lines and add your additional requirements
```
[tool.flit.metadata]
module = "pyimporters_<new_format>"
...
requires = [
    "pyimporters_plugins>=0.1.61",
    "additional_requirement1",
    "additional_requirement2",
    ...
    "additional_requirementN",
]
dist-name = "pyimporters-<new_format>"
...
[tool.flit.entrypoints."pyimporters.plugins"]
<new_format> = "pyimporters_<new_format>.<new_format>:NewFormatKnowledgeParser"
```
- Write the implementation and test of your new format in python using your favorite IDE
```
@dataclass
class NewFormatOptions(KnowledgeParserOptions):
    """
    Options for the new format knowledge import
    """
    foo : str = Query("bar", description="Yummy parameter")

NewFormatOptionsModel = NewFormatOptions.__pydantic_model__

class NewFormatKnowledgeParser(KnowledgeParserBase):
    def parse(self, source : Path, options: Union[KnowledgeParserOptions, Dict[str, Any]], bar : Bar) -> Generator[Term, None, None]:
        options = NewFormatOptions(**options) if isinstance(options, dict) else options
        # Initialize the progress indicator number of terms to read so that the progress indicator can send feedback to the end user
        bar.max = 100 
        bar.start()
        # yield as many terms as you want, advancing the progress indicator each time
        bar.next()
        yield Term(identifier=options.foo, preferredForm=options.foo)
        # Terminate the progress indicator
        bar.finish()

    @classmethod
    def get_schema(cls) -> KnowledgeParserOptions:
        return NewFormatOptions

    @classmethod
    def get_model(cls) -> Type[BaseModel]:
        return NewFormatOptionsModel
```
univoucher 2.0.1
Programmatically create UniFi Guest vouchers

# Example
```python
from univoucher import models, local
from getpass import getpass
import math

netloc = input("Netloc: ") # <host>:<port>
username = input("Username: ")
password = getpass("Password: ")

client:models.Client = local.Client(netloc, username, password)
client.verify = False

# Create one voucher
# A guest can use it for 1000 minutes when redeemed
# The voucher can be redeemed an unlimited amount of times
vouchers = client.fetch(amount=1, duration=1000, uses=math.inf)

unlimited_uses_voucher:models.Voucher = next(vouchers)

print(unlimited_uses_voucher.code)
```