semvec/pypi-packages huggingface dataset:
altearnrpc 0.1.5
Un client Discord RPC pour Altearn
License: MIT

# Altearn RPC

## Dépendances

- Python 3.8+ 
- PyPresence
- TQDM

PyPresence et TQDM sont installés automatiquement par pip

## Installation
`pip install altearnrpc`


## Mise à jour
`pip install -U altearnrpc`

## Démarrage
`python -m altearnrpc`
pydtnsim 0.1.1
A discrete event simulation library for DTN
License: MIT
Requires Python: >=3.7.0
Keywords: delay-tolerant-networking,routing,simulation,dtn,cgr

# PyDTNsim

## Introduction

This python module contains a simulation environment that allows the simulation of arbitrary Delay Tolerant Networking (DTN) scenarios on a packet (DTN terminology: bundle) level. *PyDTNsim* provides users with the ability to evaluate the performance of various routing approaches and to detect possibly occurring overload situations. Currently, the focus lies on deterministic Contact-Graph-based routing approaches, but there might be other
approaches available in the future. The clear modularization allows users to easily implement routing approaches on their own.

## More Information
Please refer to the Github repository for a more detailed overview of the module and tutorials on how to get started.
Enkryptor 0.1.1.post1
A Python module designed to be able to encrypt almost any kind of data as easily as possible for you.
License: MIT
Keywords: encryption,security,auth,authenthication

# Enkryptor

![PyPI - Python Version](https://img.shields.io/pypi/pyversions/enkryptor)
![PyPI - License](https://img.shields.io/pypi/l/enkryptor)
![PyPI - Downloads](https://img.shields.io/pypi/dd/enkryptor)
![PyPI](https://img.shields.io/pypi/v/enkryptor)

A Python module designed to be able to encrypt almost any kind of data as easily as possible for you.

It uses the cryptography module to provide you SHA256 encryption on your files with little to no intervention from you.

This is a newly made module, if you find any bugs or find a way to make it better feel free to file an issue or a pull request!

## HOW TO USE:
---

### Import the class from the module

> `from enkryptor import Enkryptor`

### Create an Enkryptor object

> `enc = Enkryptor()`

Doing this will create all of the files that Enkryptor needs to work in the same directory it's in. If they already exist, they will be reused.
Enkryptor can be safely initialised without any parameters, but you can specify either the name of the file
you want to work with or its path, like this:

> `enc = Enkryptor(file='filename.e')`

> `enc = Enkryptor(file='X:/path/to/file.e')`

Having the `.e` extension is not necessary, but it separates your encrypted file from the others. You can actually set the extension to whatever you want. If you don't specify the file, the file created will be called `enc.e`.

You might also want to store different salt files for different encrypted files. You can specify the salt file's name or directory with the `salt` parameter:

> `enc = Enkryptor(salt='saltfilename.salt')`

> `enc = Enkryptor(salt='X:/path/to/salt/file.salt')`

Again, the `.salt` extension isn't strictly necessary. If you don't specify the salt file, the file created will be called `salt.salt`.
### Pass in the password

> `enc.password("yourpass")`

Replace `yourpass` with a password, as a string. This function returns true or false depending if the password was correct or incorrect. (This feature is experimental)

### Encrypt your data

> `enc.enkrypt(data)`

Replace `data` with whichever data you might want to save encrypted into your file, preferably in a list, dictionary or tuple.
The data will be encrypted and saved into the file `enc.e` in the same directory the module is called from or into the file in the path you specified when you initialised the object.

### Decrypt your data

> `enc.dekrypt()`

You dont have to pass anything into this function. All it does is open your encrypted file, decrypt its contents, and return them.

## Bucket List

- Add an `Extras` class with full access to the functions of `Enkryptor` and other sweet stuff like a password generator.
- Add an `append` parameter to enkrypt() to simply add something to the data already encrypted instead of overwriting it
- Convert the whole module into Cython to give it better performance
- ~~Upload to PyPi so anyone can use!~~ **DONE**
crime-hotspots-uk 0.1.2
A python module that identifies and produces graphs of assult hotspots within the UK.
License: MIT

# Crime Hotspots UK
A python module that identifies and produces graphs of assult hotspots within the UK.

For full documentation click [here](https://crime-hotspots-uk.readthedocs.io/en/latest/?)

## About
This module has been programmed by organisers of Reclaim The Night Leeds. We hope it will be a useful tool for feminist and political activism groups in the UK. We do not necessarily any groups who have used this software.

## How to use
View the demo.ipynb Jupyter Notebook file for demonstration of how to use this module. We advise using the [anaconda toolkit](https://www.anaconda.com/) to install and run Jupyter Notebook.

You can also view the notebook online [here](https://github.com/Tasty213/crime-hotspots-uk/blob/main/demo.ipynb) however then you cannot change any of the variables.

## Contribute
We welcom pull requests, issues and feature suggestions. To colloborate with us on publishing data you have produced using this or any other tool email us at RTNLeeds[at]gmail.com.
subpub 1.0.0
Minimalistic, thread-safe, publish-subscribe API for Python
License: MIT
Requires Python: >=3.7
Keywords: publish subscribe pubsub subpub mqtt

Minimalistic, thread-safe, publish-subscribe API for Python

Welcome to subpub
=================

|PyPI-Versions| |PyPI-Wheel| |PyPI-Downloads| |Read-the-Docs| |License|

**subpub** provides a minimalistic, thread-safe, publish-subscribe API
for single-process Python applications.

* The latest documentation is available on `Read the Docs`_.
* The source code is available on `GitHub`_.

Example
=======

The example below demonstrates basic usage.

..  code-block:: python

    # Create an instance of the message broker
    >>> from subpub import SubPub
    >>> sp = SubPub()

    # Subscribe to a topic (= any string or regular expression).
    # The returned queue `q` is used to retrieve published data:
    >>> q = sp.subscribe(r'/food/(\w+)/order-(\d+)')

    # Publish any data to topic:
    >>> sp.publish('/food/pizza/order-66', "beef pepperoni")
    True

    # Get the published data from the queue:
    >>> match, data = q.get()
    >>> data
    'beef pepperoni'

    # The queue always receives the regexp `match` object as well.
    # It can be used to see how the topic matched and get groups:
    >>> match.groups()
    ('pizza', '66')

    # Get the published topic:
    >>> match.string
    '/food/pizza/order-66'

See test cases in ``test_subpub.py`` for more examples.

Key features
============

- SubPub's methods ``subscribe``, ``unsubscribe``, ``unsubscribe_all`` and
  ``publish`` are **thread-safe**.

- Subscribers use **regular experssions** to filter on topic.

- Subscribers receive published data through **queues**.  (There is no
  built-in mechanism to register callbacks.)

- When an queue is garbage collected, ``unsubscribe`` is executed
  **automatically** (because SubPub only keeps a weak reference to the
  subscribers' queues).

- Publishers can post any **Python object** as message.

- Publishers can use ``retain=True`` to **store** a message (as in MQTT).

Installation
============

From PyPI:

..  code-block:: bash

    $ python3 -m pip install subpub

Reference
=========

See module reference at `Read the Docs`_.

.. _Read the Docs: https://subpub.readthedocs.io/en/latest/
.. _GitHub: https://github.com/Penlect/subpub


.. |PyPI-Versions| image:: https://img.shields.io/pypi/pyversions/subpub.svg
   :target: https://pypi.org/project/subpub

.. |PyPI-Wheel| image:: https://img.shields.io/pypi/wheel/subpub.svg
   :target: https://pypi.org/project/subpub

.. |PyPI-Downloads| image:: https://img.shields.io/pypi/dm/subpub.svg
   :target: https://pypi.org/project/subpub

.. |Read-the-Docs| image:: https://img.shields.io/readthedocs/subpub.svg
   :target: https://subpub.readthedocs.io/en/latest

.. |License| image:: https://img.shields.io/github/license/Penlect/subpub.svg
   :target: https://github.com/Penlect/subpub
maznet 1.0.1
A lightweight deep learning library
License: MIT

# maznet
A lightweight deep learning library made for learning
purposes using Python. The code is easy to understand
but suggestions are welcome and feel free to contact for
queries. We extensively use type hints for better code
comprehension instead of filling our code with docstrings
and comments.

## Requirements
 - numpy

## Setup
You can either download the package from 
`pip install maznet==1.0.0`
or download this repository and use accordingly.

## Usage
See `xor.py` and `fizzbuzz.py` for usage examples

## Future work
Broaden the library functionality by adding more optimizers,
losses, layers and such.

## Contribution
To get assigned to any issue leave a comment or if
you feel you have any ideas feel free to create an issue.
Before making a pull request make sure to check code using
`mypy` for type hints and `black` for linting.

## Acknowledgments
Initial work has been inspired by joelnet.