semvec/pypi-packages huggingface dataset:
pydoods 1.0.2
A Python wrapper for the DOODS image detection service

# PyDOODS - Python for Distributed Open Object Detection Service

This is a simple Python wrapper for the [DOODS](https://github.com/snowzach/doods) service. 
DOODS allows you to do remote object detection in images easily. 

A simple example using this library:

```
import PyDOODS from pydoods

try:
    pd = PyDOODS("http://docker:8080",
                    auth_key="abc1234", timeout=90)
except OSError as err:
    print("OS error: {0}".format(err))
    exit
image = open("grace_hopper.png", "rb").read()
print(pd.detect(image))
```
PyEngine-2D 1.6.1
A lib to create 2D games

![PyEngine logo](Logo.png "PyEngine logo")

# PyEngine

A lib to build 2D Games.

## Dependencies

- Python 3.5+
- PyGame
- NumPy
- PIL
- Pymunk

## Other information

- Main Developer : LavaPower
- Contributors : X
- Develop on :
  - System :
    - Windows 10 (V 0.1.0-DEV --> Latest)
  - Version of Python :
    - 3.7.1 (V 0.1.0-DEV --> Latest)
  - Library :
    - PyGame 1.9.6 (V 0.1.0-DEV --> Latest)
    - NumPy 1.16.2 (V 1.2.0 --> Latest)
    - PIL 5.4.1 (V 1.5.0 --> Latest)
    - Pymunk 5.5.0 (V 1.6.0 --> Latest)
rknfind 2.1.0a1
Dig into RKN dump with ease
Requires Python: >=3, <4
Keywords: rkn roskomnadzor cli find

# RknFind project

## Disclaimer

This application provides tools for browsing and exporting
RKN (RosKomNadzor, a Russian communications managing autority)
dump of sites blocked in Russia.

Please note that visiting sites exposed from RKN dump by
this application may be illegal in some countries.

End user takes full responsibility for any actions made using this application,
which include, but not limited by:

-   Downloading a copy of RKN dump file from Zapret-Info Github repository
-   Retrieving a human-readable list of blocked sites/URLs/IP addresses
-   Exporting list of blocked resources to SQLite database

## Features

What can this application do?

-   Retrieve and auto-update RKN dump file
-   Process RKN dump file and print out human-readable/JSON-formatted list of
    blocked sites
-   Export list of blocked sites to SQLite database

## Usage
### Installation
Application is available at PyPI and can be retrieved using `pip`:

```bash
$ pip install rknfind
```

You can install `git` and `gitpython` module to slightly improve performance
on dump file download:
-   Git downloads - https://git-scm.com/downloads
-   GitPython installation:
    ```bash
    $ pip install rknfind[git]
    ```

You can also install `peewee` to be able to export data into SQLite database:
```bash
$ pip install rknfind[db]
```

### Launching
Once you've installed `rknfind`, just run it in terminal:
```bash
$ rknfind
```

With no filter parameters provided, `rknfind` will exit. Use `rknfind -f <field> <occurence>` to add filter. You can use `-f` flag multiple times!

List of fields:
| Field    | Description                   |
|----------|-------------------------------|
| `addr`   | List of IP addresses of entry |
| `date`   | Issue date of entry           |
| `decree` | Decree of entry               |
| `issuer` | Issuing authority of entry    |
| `domain` | List of domain names of entry |
| `url`    | List of URLs of entry         |

For info related to other flags, use `rknfind -h`
chevette 0.1.0
Chevette is a MarkDown powered static blog engine.
Requires Python: >=3.7
Keywords: static site generator

Version 0.1.0

# Chevette

Chevette is a static blog engine written in Python. It presently only supports version 3.5 and up.
There are currently no plans to add compatibility to previous versions although efforts from other contributors are most welcome.


_Note: the project is currently an alpha release._
_There are still tests that need to be performed so certain functionality might not be fully stable._

## Installation
Installation is fairly straightforward. Make sure you have either `pip` or `pipenv` installed on your system and run the following command:

```bash
pip install chevette
# or if you are using pipenv
pipenv install chevette
```
---

## Basic Usage

Installing chevette will give you access to a command line utility to help you with your needs.

### Create a blog

It's a simple as executing

```bash
chevette new <path/to/your/project/directory>
```

This will generate a basic boilerplate project for your site (Including template files).

### Build the blog

To build your blog (ie: convert all your markdown posts to html):

1. Navigate to the project directory (if you're not already there)

```bash
cd /path/to/your/project/directory
```
2. Run the `build` command
```bash
chevette build
```
This will generate all the necessary html files (including pages and other assets) and place them in a directory called `public` within the project directory.


### Launch a server
Chevette comes with a very simple http server to help you track the changes you make to your blog.

1. In a new terminal session, navigate to the `public` folder inside of your project directory (see the previous section)

```bash
cd /path/to/your/project/directory/public
```

2. Run the `serve` command
```bash
chevette serve
```

A server will be launched which will be accessible at `localhost:9310`

---

## Roadmap
As I've mentioned in the beginning of this README, chevette is still in its infancy and is very much a work in progress. There are many features I would like to implement, including the following:

* Code syntax highlighting in posts
* A drafts / unpublished mechanism
* Better logging, error messages
* More robust tests
* Add more options to the CLI commands
* Various performance tweakings
* A `publish` command as can be seen in projects like hyde or hugo
* Tidying up the codebase
* Compilation of css and javascript assets
* many more as we think of them


---

## Issues and contributing

If you come across this project and you either feel inclined to add your contribution or simply want to report a bug, the best way to so is through github issues.