semvec/pypi-packages huggingface dataset:
kube-api 0.1.65
A simple Kubernetes Python API
Requires Python: >=3.6

# Kubernetes Python API
This repository contains a simple Kubernetes Python API (Kube API). This API is built using the [Official Python client library](https://github.com/kubernetes-client/python) (Official API) for [kubernetes](http://kubernetes.io/)

## Loading the Configurations
A configuration file is required for calling the APIs. There are two ways for loading configurations:
1. Set the "KUBERNETES_CONFIG" environment variable to the path of the configuration file. The configurations will be loaded automatically.
2. Explicitly call `config.load_configuration(config_file_path)`.

## Handling Exceptions
The official API raises exceptions when there is an error. Kube API will catch the ApiException and return an error message instead. This is implemented by wrapping the function calls to the official API using the `api_request()` function in `utils.py`.

When there is an error calling the official API, Kube API will return a JSON response containing the body of the ApiException (which is a dictionary-like object), plus three (3) additional fields:
* status, the status returned in the ApiException
* error, the reason of the error
* headers, the header of the ApiException
kylink 0.0.24
Python SDK for Kylink Platform
Requires Python: >=3.8

# Kylink-py

Kylink-py, means the package for Python Toolkit for Kylink Platform

## Installation

```
pip install kylink
```

## Usage

Example: fetch and parse a USDT Transfer Event

```python
import os
import web3
import kylink
from kylink.evm import SingleEventDecoder

# for internet
ky = kylink.Kylink(api_token=YOUT_APIKEY)

log = ky.eth.events(
    "address = unhex('dac17f958d2ee523a2206206994597c13d831ec7')", limit=1
)[0]

w3 = web3.Web3()

abi = {
    "anonymous": False,
    "inputs": [
        {"indexed": True, "name": "from", "type": "address"},
        {"indexed": True, "name": "to", "type": "address"},
        {"indexed": False, "name": "value", "type": "uint256"},
    ],
    "name": "Transfer",
    "type": "event",
}
decoder = SingleEventDecoder(w3, event_abi=abi)
result = decoder.decode(log)
print(result)

```

You can read detailed guide on [our document site](https://doc.kylink.xyz/)
django-otp-yubikey 1.1.0
A django-otp plugin that verifies YubiKey OTP tokens.
Requires Python: >=3.7

.. image:: https://img.shields.io/pypi/v/django-otp-yubikey?color=blue
   :target: https://pypi.org/project/django-otp-yubikey/
   :alt: PyPI
.. image:: https://img.shields.io/readthedocs/django-otp-yubikey
   :target: https://django-otp-yubikey.readthedocs.io/
   :alt: Documentation
.. image:: https://img.shields.io/badge/github-django--agent--trust-green
   :target: https://github.com/django-otp/django-otp-yubikey
   :alt: Source

This is a django-otp plugin that handles `YubiKey
<https://www.yubico.com/yubikey>`_ devices using the Yubico OTP algorithm. This
includes two device definitions: one to verify YubiKey tokens locally and
another to verify them against a `web service
<https://www.yubico.com/yubicloud>`_.

See `django-otp <https://pypi.org/project/django-otp>`_ for more information on
the OTP framework.

.. end-of-doc-intro


Development
-----------

This project is built and managed with `hatch`_. If you don't have hatch, I
recommend installing it with `pipx`_: ``pipx install hatch``.

``pyproject.toml`` defines several useful scripts for development and testing.
The default environment includes all dev and test dependencies for quickly
running tests. The ``test`` environment defines the test matrix for running the
full validation suite. Everything is executed in the context of the Django
project in test/test\_project.

As a quick primer, hatch scripts can be run with ``hatch run [<env>:]<script>``.
To run linters and tests in the default environment, just run
``hatch run check``. This should run tests with your default Python version and
the latest Django. Other scripts include:

* **manage**: Run a management command via the test project. This can be used to
  generate migrations.
* **lint**: Run all linters.
* **fix**: Run all fixers to address linting issues. This may not fix every
  issue reported by lint.
* **test**: Run all tests.
* **check**: Run linters and tests.
* **warn**: Run tests with all warnings enabled. This is especially useful for
  seeing deprecation warnings in new versions of Django.
* **cov**: Run tests and print a code coverage report.

To run the full test matrix, run ``hatch run test:run``. You will need multiple
specific Python versions installed for this.

You can clean up the hatch environments with ``hatch env prune``, for example to
force dependency updates.


.. _hatch: https://hatch.pypa.io/
.. _pipx: https://pypa.github.io/pipx/
django-otp-twilio 1.0.5
A django-otp plugin that delivers tokens via Twilio's SMS service.
Requires Python: >=3.7

.. image:: https://img.shields.io/pypi/v/django-otp-twilio?color=blue
   :target: https://pypi.org/project/django-otp-twilio/
   :alt: PyPI
.. image:: https://img.shields.io/readthedocs/django-otp-twilio
   :target: https://django-otp-twilio.readthedocs.io/
   :alt: Documentation
.. image:: https://img.shields.io/badge/github-django--otp--twilio-green
   :target: https://github.com/django-otp/django-otp-twilio
   :alt: Source

This is a django-otp plugin that delivers tokens via Twilio's `SMS
<https://www.twilio.com/sms>`_ service.

See `django-otp <https://pypi.org/project/django-otp>`_ for more information
on the OTP framework.

.. end-of-doc-intro


Development
-----------

This project is built and managed with `hatch`_. If you don't have hatch, I
recommend installing it with `pipx`_: ``pipx install hatch``.

``pyproject.toml`` defines several useful scripts for development and testing.
The default environment includes all dev and test dependencies for quickly
running tests. The ``test`` environment defines the test matrix for running the
full validation suite. Everything is executed in the context of the Django
project in test/test\_project.

As a quick primer, hatch scripts can be run with ``hatch run [<env>:]<script>``.
To run linters and tests in the default environment, just run
``hatch run check``. This should run tests with your default Python version and
the latest Django. Other scripts include:

* **manage**: Run a management command via the test project. This can be used to
  generate migrations.
* **lint**: Run all linters.
* **fix**: Run all fixers to address linting issues. This may not fix every
  issue reported by lint.
* **test**: Run all tests.
* **check**: Run linters and tests.
* **warn**: Run tests with all warnings enabled. This is especially useful for
  seeing deprecation warnings in new versions of Django.
* **cov**: Run tests and print a code coverage report.

To run the full test matrix, run ``hatch run test:run``. You will need multiple
specific Python versions installed for this.

You can clean up the hatch environments with ``hatch env prune``, for example to
force dependency updates.


.. _hatch: https://hatch.pypa.io/
.. _pipx: https://pypa.github.io/pipx/
pseudoservice 0.1.0
A simple threaded task launcher that emulates unix service-unit style behavior
Requires Python: >=3.6

# PseudoService
*A simple threaded task launcher that emulates unix service-unit style behavior*.

## Introduction

PseudoService is a simple scheduled threading task manager for Python applications. It provides a convenient way to manage tasks in a threaded environment.

## Usage

To use PseudoService, follow these steps:

1. Import the `Launcher` class from the `pseudoservice` module.
2. Define your tasks as a dictionary where each key represents a task name and each value is a dictionary specifying the task details.
3. Initialize an instance of `Launcher` with your tasks.
4. Start the tasks using the `start_tasks()` method.

### Example Usage

```
from pseudoservice import Launcher
import mytask_1
import mytask_2
import mytask_3

# Define tasks
tasks = {
    'My first task': {  # A task that will restart if the thread is closed.
        'task': mytask_1,
        'restart': True
    },
    'My second task': {  # A task with arguments that will run once and then close.
        'task': mytask_2,
        'args': [var_1, var_2, var_3]
    },
    'My third task': {  # A task with arguments and keyword arguments that will restart if the thread is closed.
        'task': mytask_3,
        'args': [var_1, var_2],
        'kwargs': {'varname_1': var_1, 'varname_2': var_2},
        'restart': True
    },
}

# Initialize and start tasks
task_launcher = Launcher(tasks)
task_launcher.start_tasks()
```

## Launcher Class
```
Launcher(tasks: dict)
```

Initialize the Launcher class with a dictionary of tasks.

## Methods

start_tasks(): Launches the threaded tasks.

## Task Configuration

Each task is defined by a dictionary with the following keys:

- task: Required. Specifies the task to be executed.
- args: Optional. Arguments to be passed to the task function.
- kwargs: Optional. Keyword arguments to be passed to the task function.
- restart: Optional. Specifies whether the task should restart if the thread is closed.
- delay: Optional. Specifies the delay (in seconds) between successive executions of the task.
Notes

- Tasks are executed in separate threads.
- The Launcher class handles task scheduling and thread management.

### Initialization

PseudoService can be installed from pip.
```
pip install pseudoservice
```
## Credits

PseudoService was developed by Manbehindthemadness.
neuralpde 0.0.1
Neuralpde combines differentiable ode solvers with CNNs to learn PDEs using the method of lines
Requires Python: >=3.9
Keywords: neuralpde, torch

# NeuralPDE: Modelling Dynamical Systems from Data

This is the repository containing themodels for the __NeuralPDE: Modelling Dynamical Systems from Data__ paper (accepted at KI 2022)

Many physical processes such as weather phenomena or fluid mechanics are governed by partial differential equations (PDEs). Modelling such dynamical systems using Neural Networks is an active research field. However, current methods are still very limited, as they do not exploit the knowledge about the dynamical nature of the system, require extensive prior knowledge about the governing equations or are limited to linear or first-order equations. In this work we make the observation that the Method of Lines used to solve PDEs can be represented using convolutions which makes convolutional neural networks (CNNs) the natural choice to parametrize arbitrary PDE dynamics. We combine this parametrization with differentiable ODE solvers to form the NeuralPDE Model, which explicitly takes into account the fact that the data is governed by differential equations. We show in several experiments on toy and real-world data that our model consistently outperforms state-of-the-art models used to learn dynamical systems. 


## License

The source code is licensed under the [MIT license](LICENSE).