semvec/pypi-packages huggingface dataset:
simple-tcp 0.6
A simple TCP client and server for easy testing

# SIMPLE TCP TESTING TOOL
Simple tools to manually test socket programming project. Requires python3.

## Features:
- Arguments can be inputted via command line arguments vs via interactive console
- Verbose mode vs silent mode
- SSL/TLS wrapped socket (optional)
- Does not require additional python module (only using ```socket```, ```argparse```, ```ssl```, and ```sys```)

## Common Usage:
- ```python3 simple_tcp.py -s -p 3000```: start server socket on port 3000 and accept connection from all interface
- ```python3 simple_tcp.py -c -h 192.168.1.20 -p 3000```: connect to 192.168.1.20:3000
- ```python3 simple_tcp.py -i```: interactive mode, the script will ask for host, port and mode interactively (easier for noobs)

## Arguments:
- "-h"/"--help": display all command line arguments
- "-a"/"--host": (optional) set target host, ex: ```-a 192.168.137.20```, will default to ```localhost``` if not set
- "-p"/"--port": (optional) set target port, ex: ```-p 8888```, will default to ```80``` if not set
- "-b"/"--buffer": (optional) set buffer size, ex: ```-b 1024```, will default to ```4092``` if not set
- flag mode: "-s"/"--server" or "-c"/"--client", can only choose one, will default to client mode if not set
- flag interactive: "-i"/"--interactive", ask for host, port, buffer, and mode interactively (automatically assumed if no arguments provided)
- flag verbose: "--verbose", display verbose output (useful for debugging)

### SSL Arguments:
- flag ssl: "--ssl": add this flag to use ssl mode
- "--ssl_server_certificate": set path to ssl server certificate (for ssl server mode only)
- "--ssl_server_privatekey": set path to ssl server private key (for ssl server mode only)
- "--ssl_client_ca": set path to certificate authority (CA)'s certificate (for ssl client mode only)
dinosaur-pygame 0.0.8
A dinosaur game made with pygame
Requires Python: >=3.5

You are a dinosaur, and you have to dodge the meteors by moving the mouse. If a meteor hits you, you lose a life. Hopefully, you always can eat a ham to recover some lives.

I made this game to learn how to use `pygame` in my 2nd year of my studies. I recently updated it to support Python 3, and to polish a bit the project (mainly translating the comments and code into English).

I also left the original one in `first_version` folder just for the old times :D

I recently uploaded the application to https://pypi.org/ to learn how to publish Python packages.

## Installation
This app is uploaded in https://pypi.org/. To install and run it, you just need to (you may want to run it on a virtualenv):
```
pip install dinosaur-pygame
dinosaur_pygame  # The game is installed as a script, just needs to run that command for the game to start.
```

## Local Development
You may need to [install some prerequisites](https://www.pygame.org/wiki/GettingStarted) to make `pygame` work. Once they are installed, to install the project:
```
make install
# `make clean` can be run to reset the project to a clean state
```

#### To run the application:
```
make run
```

#### To install the package and check if it works before publishing the new version into https://pypi.org/:
```
make install_package  # This will run the game as a console script after the package has been built.
dinosaur_pygame  # manually checks if it runs properly in the console. Run this with your venv activated.
```
Good starting documentation for pypi packages: https://packaging.python.org/tutorials/packaging-projects/ and https://python-packaging.readthedocs.io/en/latest/command-line-scripts.html#the-console-scripts-entry-point.

#### To publish the new package in test pypi
This will upload the package to test pypi. This is a good way of testing if the package will work before publishing it into the real pypi.
```
make upload_package_to_test_pypi  # it requires the test token
python3 -m pip install --index-url https://test.pypi.org/simple/ --no-deps dinosaur-pygame=={VERSION}
dinosaur_pygame  # Run the app
```

#### To publish the new package in pypi
Once every change have been thoroughly tested, we can upload the new version into the real https://pypi.org/.

A new version will be needed (`setup.py`), as existing versions in `pypi` cannot be modified.
```
make upload_package_to_pypi  # it requires the token
pip install dinosaur-pygame  # a version can be specified by dinosaur-pygame=={VERSION}
dinosaur_pygame  # runs the app
```

## Art
For the new version, I got the images from https://opengameart.org/:
- Background: https://opengameart.org/content/sky-tiles
- Dinosaur: https://opengameart.org/content/dinosaur-0
- Meteor: https://opengameart.org/content/meteor-animated-64x64
- Ham: https://opengameart.org/content/32x32-food-set

Author: Alberto Morales
python-latex 1.0.1
Convenience wrappers around latex compilation with python

# python-latex

LaTex has a billion different compilers with fiddly controls and lots of dependencies to install.
Turns out there is a latex python package with a nice and simple interface. No fiddling with containerization and volume mounts. No funky interface to learn.

```
pip3 install python_latex
python_latex
touch some-existing-latex-file.tex
```

A `python_latex` command is exposed, will watch the current directory for _changes_ to any `.tex` file, and compile them to a `.pdf`, without all those useless intermediary files most compilers create.

Use a nice pdf viewer that auto-refreshes, like `zathura`, to continuously develop a file.
pph 0.2.0
Practical Perfect Hashing module

pph
=========

pph generates a minimal order-preserving hash function for a list of keys.

Reference:

Practical perfect hashing
GV Cormack, RNS Horspool, M Kaiserswerth - The Computer Journal, 1985

# Table of Contents

- [License](#license)
- [Building](#building)
- [Using](#using)

# License

This project is licensed under the [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).

# Building

This library uses the Boost library.

    export LDFLAGS="$LDFLAGS -L/path/to/boost/lib"
    export CPPFLAGS="$CPPFLAGS -I/path/to/boost/include"

pph uses CMake for its build system.

    mkdir build
    cd build
    cmake ..
    make

# Using

The basic command line to generate a hash function from a file containing a list of strings (one per line) is:

    pph -i ./file.txt -o ./file.hash

The command line to verify an existing hash function is:

    pph --verify ./file.hash

The other command line options can be seen by typing:

    pph --help

The default timeout for creating a hash function is 60000 milliseconds (1 minute).

If a hash function is not generated, you can try sorting the input file:  

    pph -i file.txt --index > file_index.txt
    sort --numeric-sort --key=2 file_index.txt > file_sorted_index.txt
    awk -F' ' '{print $1}'  file_sorted_index.txt > file_sorted.txt


# Python

This library uses the Boost library. Install the Boost library and set **LDFLAGS** and **CPPFLAGS** before installing the Python module.

    export LDFLAGS="$LDFLAGS -L/path/to/boost/lib"
    export CPPFLAGS="$CPPFLAGS -I/path/to/boost/include"
    
Install the module.

    pip3 install pph

Import the module.

    from pph import PphHashTable, PphRandomNumber, PphKeyFunctions

See the tests for how to generate a hash function using the Python interface.