add venv

.gitignore

@@ -105,12 +105,9 @@ celerybeat.pid
 
 # Environments
 .env
-.venv
 env/
-venv/
 ENV/
 env.bak/
-venv.bak/
 
 # Spyder project settings
 .spyderproject

venv/Include/site/python3.7/pygame/_camera.h

@@ -0,0 +1,27 @@
+/*
+  pygame - Python Game Library
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not, write to the Free
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#ifndef _CAMERA_H
+#define _CAMERA_H
+
+#include "_pygame.h"
+#include "camera.h"
+
+#endif
+

venv/Include/site/python3.7/pygame/_pygame.h

@@ -0,0 +1,864 @@
+/*
+    pygame - Python Game Library
+    Copyright (C) 2000-2001  Pete Shinners
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Pete Shinners
+    pete@shinners.org
+*/
+
+#ifndef _PYGAME_H
+#define _PYGAME_H
+
+/** This header file includes all the definitions for the
+ ** base pygame extensions. This header only requires
+ ** SDL and Python includes. The reason for functions
+ ** prototyped with #define's is to allow for maximum
+ ** python portability. It also uses python as the
+ ** runtime linker, which allows for late binding. For more
+ ** information on this style of development, read the Python
+ ** docs on this subject.
+ ** http://www.python.org/doc/current/ext/using-cobjects.html
+ **
+ ** If using this to build your own derived extensions,
+ ** you'll see that the functions available here are mainly
+ ** used to help convert between python objects and SDL objects.
+ ** Since this library doesn't add a lot of functionality to
+ ** the SDL libarary, it doesn't need to offer a lot either.
+ **
+ ** When initializing your extension module, you must manually
+ ** import the modules you want to use. (this is the part about
+ ** using python as the runtime linker). Each module has its
+ ** own import_xxx() routine. You need to perform this import
+ ** after you have initialized your own module, and before
+ ** you call any routines from that module. Since every module
+ ** in pygame does this, there are plenty of examples.
+ **
+ ** The base module does include some useful conversion routines
+ ** that you are free to use in your own extension.
+ **
+ ** When making changes, it is very important to keep the
+ ** FIRSTSLOT and NUMSLOT constants up to date for each
+ ** section. Also be sure not to overlap any of the slots.
+ ** When you do make a mistake with this, it will result
+ ** is a dereferenced NULL pointer that is easier to diagnose
+ ** than it could be :]
+ **/
+#if defined(HAVE_SNPRINTF) /* defined in python.h (pyerrors.h) and SDL.h \
+                              (SDL_config.h) */
+#undef HAVE_SNPRINTF       /* remove GCC redefine warning */
+#endif
+
+// This must be before all else
+#if defined(__SYMBIAN32__) && defined(OPENC)
+#include <sys/types.h>
+
+#if defined(__WINS__)
+void *
+_alloca(size_t size);
+#define alloca _alloca
+#endif
+#endif
+
+#define PG_STRINGIZE_HELPER(x) #x
+#define PG_STRINGIZE(x) PG_STRINGIZE_HELPER(x)
+#define PG_WARN(desc) message(__FILE__ "(" PG_STRINGIZE(__LINE__) "): WARNING: " #desc)
+
+/* This is unconditionally defined in Python.h */
+#if defined(_POSIX_C_SOURCE)
+#undef _POSIX_C_SOURCE
+#endif
+
+#include <Python.h>
+
+/* the version macros are defined since version 1.9.5 */
+#define PG_MAJOR_VERSION 1
+#define PG_MINOR_VERSION 9
+#define PG_PATCH_VERSION 6
+#define PG_VERSIONNUM(MAJOR, MINOR, PATCH) (1000*(MAJOR) + 100*(MINOR) + (PATCH))
+#define PG_VERSION_ATLEAST(MAJOR, MINOR, PATCH)                             \
+    (PG_VERSIONNUM(PG_MAJOR_VERSION, PG_MINOR_VERSION, PG_PATCH_VERSION) >= \
+     PG_VERSIONNUM(MAJOR, MINOR, PATCH))
+
+/* Cobjects vanish in Python 3.2; so we will code as though we use capsules */
+#if defined(Py_CAPSULE_H)
+#define PG_HAVE_CAPSULE 1
+#else
+#define PG_HAVE_CAPSULE 0
+#endif
+#if defined(Py_COBJECT_H)
+#define PG_HAVE_COBJECT 1
+#else
+#define PG_HAVE_COBJECT 0
+#endif
+#if !PG_HAVE_CAPSULE
+#define PyCapsule_New(ptr, n, dfn) PyCObject_FromVoidPtr(ptr, dfn)
+#define PyCapsule_GetPointer(obj, n) PyCObject_AsVoidPtr(obj)
+#define PyCapsule_CheckExact(obj) PyCObject_Check(obj)
+#endif
+
+/* Pygame uses Py_buffer (PEP 3118) to exchange array information internally;
+ * define here as needed.
+ */
+#if !defined(PyBUF_SIMPLE)
+typedef struct bufferinfo {
+    void *buf;
+    PyObject *obj;
+    Py_ssize_t len;
+    Py_ssize_t itemsize;
+    int readonly;
+    int ndim;
+    char *format;
+    Py_ssize_t *shape;
+    Py_ssize_t *strides;
+    Py_ssize_t *suboffsets;
+    void *internal;
+} Py_buffer;
+
+/* Flags for getting buffers */
+#define PyBUF_SIMPLE 0
+#define PyBUF_WRITABLE 0x0001
+/*  we used to include an E, backwards compatible alias  */
+#define PyBUF_WRITEABLE PyBUF_WRITABLE
+#define PyBUF_FORMAT 0x0004
+#define PyBUF_ND 0x0008
+#define PyBUF_STRIDES (0x0010 | PyBUF_ND)
+#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)
+#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)
+#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)
+#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)
+
+#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE)
+#define PyBUF_CONTIG_RO (PyBUF_ND)
+
+#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE)
+#define PyBUF_STRIDED_RO (PyBUF_STRIDES)
+
+#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT)
+#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT)
+
+#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT)
+#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT)
+
+#define PyBUF_READ 0x100
+#define PyBUF_WRITE 0x200
+#define PyBUF_SHADOW 0x400
+
+typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
+typedef void (*releasebufferproc)(Py_buffer *);
+#endif /* #if !defined(PyBUF_SIMPLE) */
+
+/* Flag indicating a pg_buffer; used for assertions within callbacks */
+#ifndef NDEBUG
+#define PyBUF_PYGAME 0x4000
+#endif
+
+#define PyBUF_HAS_FLAG(f, F) (((f) & (F)) == (F))
+
+/* Array information exchange struct C type; inherits from Py_buffer
+ *
+ * Pygame uses its own Py_buffer derived C struct as an internal representation
+ * of an imported array buffer. The extended Py_buffer allows for a
+ * per-instance release callback,
+ */
+typedef void (*pybuffer_releaseproc)(Py_buffer *);
+
+typedef struct pg_bufferinfo_s {
+    Py_buffer view;
+    PyObject *consumer; /* Input: Borrowed reference */
+    pybuffer_releaseproc release_buffer;
+} pg_buffer;
+
+/* Operating system specific adjustments
+ */
+// No signal()
+#if defined(__SYMBIAN32__) && defined(HAVE_SIGNAL_H)
+#undef HAVE_SIGNAL_H
+#endif
+
+#if defined(HAVE_SNPRINTF)
+#undef HAVE_SNPRINTF
+#endif
+
+#ifdef MS_WIN32 /*Python gives us MS_WIN32, SDL needs just WIN32*/
+#ifndef WIN32
+#define WIN32
+#endif
+#endif
+
+/// Prefix when initializing module
+#define MODPREFIX ""
+/// Prefix when importing module
+#define IMPPREFIX "pygame."
+
+#ifdef __SYMBIAN32__
+#undef MODPREFIX
+#undef IMPPREFIX
+// On Symbian there is no pygame package. The extensions are built-in or in
+// sys\bin.
+#define MODPREFIX "pygame_"
+#define IMPPREFIX "pygame_"
+#endif
+
+#include <SDL.h>
+
+/* Pygame's SDL version macros:
+ *   IS_SDLv1 is 1 if SDL 1.x.x, 0 otherwise
+ *   IS_SDLv2 is 1 if at least SDL 2.0.0, 0 otherwise
+ */
+#if (SDL_VERSION_ATLEAST(2, 0, 0))
+#define IS_SDLv1 0
+#define IS_SDLv2 1
+#else
+#define IS_SDLv1 1
+#define IS_SDLv2 0
+#endif
+
+/*#if IS_SDLv1 && PG_MAJOR_VERSION >= 2
+#error pygame 2 requires SDL 2
+#endif*/
+
+#if IS_SDLv2
+/* SDL 1.2 constants removed from SDL 2 */
+typedef enum {
+    SDL_HWSURFACE = 0,
+    SDL_RESIZABLE = SDL_WINDOW_RESIZABLE,
+    SDL_ASYNCBLIT = 0,
+    SDL_OPENGL = SDL_WINDOW_OPENGL,
+    SDL_OPENGLBLIT = 0,
+    SDL_ANYFORMAT = 0,
+    SDL_HWPALETTE = 0,
+    SDL_DOUBLEBUF = 0,
+    SDL_FULLSCREEN = SDL_WINDOW_FULLSCREEN,
+    SDL_HWACCEL = 0,
+    SDL_SRCCOLORKEY = 0,
+    SDL_RLEACCELOK = 0,
+    SDL_SRCALPHA = 0,
+    SDL_NOFRAME = SDL_WINDOW_BORDERLESS,
+    SDL_GL_SWAP_CONTROL = 0,
+    TIMER_RESOLUTION = 0
+} PygameVideoFlags;
+
+/* the wheel button constants were removed from SDL 2 */
+typedef enum {
+    PGM_BUTTON_LEFT = SDL_BUTTON_LEFT,
+    PGM_BUTTON_RIGHT = SDL_BUTTON_RIGHT,
+    PGM_BUTTON_MIDDLE = SDL_BUTTON_MIDDLE,
+    PGM_BUTTON_WHEELUP = 4,
+    PGM_BUTTON_WHEELDOWN = 5,
+    PGM_BUTTON_X1 = SDL_BUTTON_X1 + 2,
+    PGM_BUTTON_X2 = SDL_BUTTON_X2 + 2,
+    PGM_BUTTON_KEEP = 0x80
+} PygameMouseFlags;
+
+typedef enum {
+    SDL_NOEVENT = 0,
+    /* SDL 1.2 allowed for 8 user defined events. */
+    SDL_NUMEVENTS = SDL_USEREVENT + 8,
+    SDL_ACTIVEEVENT = SDL_NUMEVENTS,
+    PGE_EVENTBEGIN = SDL_NUMEVENTS,
+    SDL_VIDEORESIZE,
+    SDL_VIDEOEXPOSE,
+    PGE_KEYREPEAT,
+    PGE_EVENTEND
+} PygameEventCode;
+
+#define PGE_NUMEVENTS (PGE_EVENTEND - PGE_EVENTBEGIN)
+
+typedef enum {
+    SDL_APPFOCUSMOUSE,
+    SDL_APPINPUTFOCUS,
+    SDL_APPACTIVE
+} PygameAppCode;
+
+/* Surface flags: based on SDL 1.2 flags */
+typedef enum {
+    PGS_SWSURFACE = 0x00000000,
+    PGS_HWSURFACE = 0x00000001,
+    PGS_ASYNCBLIT = 0x00000004,
+
+    PGS_ANYFORMAT = 0x10000000,
+    PGS_HWPALETTE = 0x20000000,
+    PGS_DOUBLEBUF = 0x40000000,
+    PGS_FULLSCREEN = 0x80000000,
+    PGS_OPENGL = 0x00000002,
+    PGS_OPENGLBLIT = 0x0000000A,
+    PGS_RESIZABLE = 0x00000010,
+    PGS_NOFRAME = 0x00000020,
+    PGS_SHOWN = 0x00000040,  /* Added from SDL 2 */
+    PGS_HIDDEN = 0x00000080, /* Added from SDL 2 */
+
+    PGS_HWACCEL = 0x00000100,
+    PGS_SRCCOLORKEY = 0x00001000,
+    PGS_RLEACCELOK = 0x00002000,
+    PGS_RLEACCEL = 0x00004000,
+    PGS_SRCALPHA = 0x00010000,
+    PGS_PREALLOC = 0x01000000
+} PygameSurfaceFlags;
+
+typedef struct {
+    Uint32 hw_available:1;
+    Uint32 wm_available:1;
+    Uint32 blit_hw:1;
+    Uint32 blit_hw_CC:1;
+    Uint32 blit_hw_A:1;
+    Uint32 blit_sw:1;
+    Uint32 blit_sw_CC:1;
+    Uint32 blit_sw_A:1;
+    Uint32 blit_fill:1;
+    Uint32 video_mem;
+    SDL_PixelFormat *vfmt;
+    SDL_PixelFormat vfmt_data;
+    int current_w;
+    int current_h;
+} pg_VideoInfo;
+
+#endif /* IS_SDLv2 */
+/* macros used throughout the source */
+#define RAISE(x, y) (PyErr_SetString((x), (y)), (PyObject *)NULL)
+
+#ifdef WITH_THREAD
+#define PG_CHECK_THREADS() (1)
+#else /* ~WITH_THREAD */
+#define PG_CHECK_THREADS()                        \
+    (RAISE(PyExc_NotImplementedError,             \
+          "Python built without thread support"))
+#endif /* ~WITH_THREAD */
+
+#define PyType_Init(x) (((x).ob_type) = &PyType_Type)
+#define PYGAMEAPI_LOCAL_ENTRY "_PYGAME_C_API"
+
+#ifndef MIN
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#endif
+
+#ifndef MAX
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef ABS
+#define ABS(a) (((a) < 0) ? -(a) : (a))
+#endif
+
+/* test sdl initializations */
+#define VIDEO_INIT_CHECK()            \
+    if (!SDL_WasInit(SDL_INIT_VIDEO)) \
+    return RAISE(pgExc_SDLError, "video system not initialized")
+
+#define CDROM_INIT_CHECK()            \
+    if (!SDL_WasInit(SDL_INIT_CDROM)) \
+    return RAISE(pgExc_SDLError, "cdrom system not initialized")
+
+#define JOYSTICK_INIT_CHECK()            \
+    if (!SDL_WasInit(SDL_INIT_JOYSTICK)) \
+    return RAISE(pgExc_SDLError, "joystick system not initialized")
+
+/* BASE */
+#define VIEW_CONTIGUOUS 1
+#define VIEW_C_ORDER 2
+#define VIEW_F_ORDER 4
+
+#define PYGAMEAPI_BASE_FIRSTSLOT 0
+#if IS_SDLv1
+#define PYGAMEAPI_BASE_NUMSLOTS 19
+#else /* IS_SDLv2 */
+#define PYGAMEAPI_BASE_NUMSLOTS 23
+#endif /* IS_SDLv2 */
+#ifndef PYGAMEAPI_BASE_INTERNAL
+#define pgExc_SDLError ((PyObject *)PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT])
+
+#define pg_RegisterQuit \
+    (*(void (*)(void (*)(void)))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 1])
+
+#define pg_IntFromObj \
+    (*(int (*)(PyObject *, int *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 2])
+
+#define pg_IntFromObjIndex      \
+    (*(int (*)(PyObject *, int, \
+               int *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 3])
+
+#define pg_TwoIntsFromObj         \
+    (*(int (*)(PyObject *, int *, \
+               int *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 4])
+
+#define pg_FloatFromObj \
+    (*(int (*)(PyObject *, float *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 5])
+
+#define pg_FloatFromObjIndex    \
+    (*(int (*)(PyObject *, int, \
+               float *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 6])
+
+#define pg_TwoFloatsFromObj         \
+    (*(int (*)(PyObject *, float *, \
+               float *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 7])
+
+#define pg_UintFromObj     \
+    (*(int (*)(PyObject *, \
+               Uint32 *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 8])
+
+#define pg_UintFromObjIndex     \
+    (*(int (*)(PyObject *, int, \
+               Uint32 *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 9])
+
+#define pgVideo_AutoQuit \
+    (*(void (*)(void))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 10])
+
+#define pgVideo_AutoInit \
+    (*(int (*)(void))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 11])
+
+#define pg_RGBAFromObj     \
+    (*(int (*)(PyObject *, \
+               Uint8 *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 12])
+
+#define pgBuffer_AsArrayInterface   \
+    (*(PyObject * (*)(Py_buffer *)) \
+         PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 13])
+
+#define pgBuffer_AsArrayStruct      \
+    (*(PyObject * (*)(Py_buffer *)) \
+         PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 14])
+
+#define pgObject_GetBuffer              \
+    (*(int (*)(PyObject *, pg_buffer *, \
+               int))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 15])
+
+#define pgBuffer_Release \
+    (*(void (*)(pg_buffer *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 16])
+
+#define pgDict_AsBuffer                 \
+    (*(int (*)(pg_buffer *, PyObject *, \
+               int))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 17])
+
+#define pgExc_BufferError \
+    ((PyObject *)PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 18])
+
+#if IS_SDLv2
+#define pg_GetDefaultWindow \
+    (*(SDL_Window * (*)(void)) PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 19])
+
+#define pg_SetDefaultWindow \
+    (*(void (*)(SDL_Window *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 20])
+
+#define pg_GetDefaultWindowSurface \
+    (*(PyObject * (*)(void)) PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 21])
+
+#define pg_SetDefaultWindowSurface \
+    (*(void (*)(PyObject *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 22])
+
+#endif /* IS_SDLv2 */
+
+#define import_pygame_base() IMPORT_PYGAME_MODULE(base, BASE)
+#endif
+
+/* RECT */
+#define PYGAMEAPI_RECT_FIRSTSLOT \
+    (PYGAMEAPI_BASE_FIRSTSLOT + PYGAMEAPI_BASE_NUMSLOTS)
+#define PYGAMEAPI_RECT_NUMSLOTS 4
+
+#if IS_SDLv1
+typedef struct {
+    int x, y;
+    int w, h;
+} GAME_Rect;
+#else
+typedef SDL_Rect GAME_Rect;
+#endif
+
+typedef struct {
+    PyObject_HEAD GAME_Rect r;
+    PyObject *weakreflist;
+} pgRectObject;
+
+#define pgRect_AsRect(x) (((pgRectObject *)x)->r)
+#ifndef PYGAMEAPI_RECT_INTERNAL
+#define pgRect_Check(x) \
+    ((x)->ob_type ==    \
+     (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 0])
+#define pgRect_Type \
+    (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 0])
+#define pgRect_New \
+    (*(PyObject * (*)(SDL_Rect *)) PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 1])
+#define pgRect_New4                        \
+    (*(PyObject * (*)(int, int, int, int)) \
+         PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 2])
+#define pgRect_FromObject                        \
+    (*(GAME_Rect * (*)(PyObject *, GAME_Rect *)) \
+         PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 3])
+
+#define import_pygame_rect() IMPORT_PYGAME_MODULE(rect, RECT)
+#endif
+
+/* CDROM */
+#define PYGAMEAPI_CDROM_FIRSTSLOT \
+    (PYGAMEAPI_RECT_FIRSTSLOT + PYGAMEAPI_RECT_NUMSLOTS)
+#define PYGAMEAPI_CDROM_NUMSLOTS 2
+
+typedef struct {
+    PyObject_HEAD int id;
+} pgCDObject;
+
+#define pgCD_AsID(x) (((pgCDObject *)x)->id)
+#ifndef PYGAMEAPI_CDROM_INTERNAL
+#define pgCD_Check(x) \
+    ((x)->ob_type ==  \
+     (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_CDROM_FIRSTSLOT + 0])
+#define pgCD_Type \
+    (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_CDROM_FIRSTSLOT + 0])
+#define pgCD_New \
+    (*(PyObject * (*)(int)) PyGAME_C_API[PYGAMEAPI_CDROM_FIRSTSLOT + 1])
+
+#define import_pygame_cd() IMPORT_PYGAME_MODULE(cdrom, CDROM)
+#endif
+
+/* JOYSTICK */
+#define PYGAMEAPI_JOYSTICK_FIRSTSLOT \
+    (PYGAMEAPI_CDROM_FIRSTSLOT + PYGAMEAPI_CDROM_NUMSLOTS)
+#define PYGAMEAPI_JOYSTICK_NUMSLOTS 2
+
+typedef struct {
+    PyObject_HEAD int id;
+} pgJoystickObject;
+
+#define pgJoystick_AsID(x) (((pgJoystickObject *)x)->id)
+
+#ifndef PYGAMEAPI_JOYSTICK_INTERNAL
+#define pgJoystick_Check(x) \
+    ((x)->ob_type ==        \
+     (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_JOYSTICK_FIRSTSLOT + 0])
+
+#define pgJoystick_Type \
+    (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_JOYSTICK_FIRSTSLOT + 0])
+#define pgJoystick_New \
+    (*(PyObject * (*)(int)) PyGAME_C_API[PYGAMEAPI_JOYSTICK_FIRSTSLOT + 1])
+
+#define import_pygame_joystick() IMPORT_PYGAME_MODULE(joystick, JOYSTICK)
+#endif
+
+/* DISPLAY */
+#define PYGAMEAPI_DISPLAY_FIRSTSLOT \
+    (PYGAMEAPI_JOYSTICK_FIRSTSLOT + PYGAMEAPI_JOYSTICK_NUMSLOTS)
+#define PYGAMEAPI_DISPLAY_NUMSLOTS 2
+
+typedef struct {
+#if IS_SDLv1
+    PyObject_HEAD SDL_VideoInfo info;
+#else
+    PyObject_HEAD pg_VideoInfo info;
+#endif
+} pgVidInfoObject;
+
+#define pgVidInfo_AsVidInfo(x) (((pgVidInfoObject *)x)->info)
+#ifndef PYGAMEAPI_DISPLAY_INTERNAL
+#define pgVidInfo_Check(x) \
+    ((x)->ob_type ==       \
+     (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 0])
+
+#define pgVidInfo_Type \
+    (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 0])
+
+#if IS_SDLv1
+#define pgVidInfo_New                   \
+    (*(PyObject * (*)(SDL_VideoInfo *)) \
+         PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 1])
+#else
+#define pgVidInfo_New                   \
+    (*(PyObject * (*)(pg_VideoInfo *)) \
+         PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 1])
+#endif
+
+#define import_pygame_display() IMPORT_PYGAME_MODULE(display, DISPLAY)
+#endif
+
+/* SURFACE */
+#define PYGAMEAPI_SURFACE_FIRSTSLOT \
+    (PYGAMEAPI_DISPLAY_FIRSTSLOT + PYGAMEAPI_DISPLAY_NUMSLOTS)
+#define PYGAMEAPI_SURFACE_NUMSLOTS 3
+typedef struct {
+    PyObject_HEAD SDL_Surface *surf;
+#if IS_SDLv2
+    int owner;
+#endif                                    /* IS_SDLv2 */
+    struct pgSubSurface_Data *subsurface; /*ptr to subsurface data (if a
+                                           * subsurface)*/
+    PyObject *weakreflist;
+    PyObject *locklist;
+    PyObject *dependency;
+} pgSurfaceObject;
+#define pgSurface_AsSurface(x) (((pgSurfaceObject *)x)->surf)
+#ifndef PYGAMEAPI_SURFACE_INTERNAL
+#define pgSurface_Check(x)    \
+    (PyObject_IsInstance((x), \
+        (PyObject *)PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 0]))
+#define pgSurface_Type \
+    (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 0])
+#if IS_SDLv1
+#define pgSurface_New                 \
+    (*(PyObject * (*)(SDL_Surface *)) \
+         PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 1])
+#else /* IS_SDLv2 */
+#define pgSurface_New2                     \
+    (*(PyObject * (*)(SDL_Surface *, int)) \
+         PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 1])
+#endif /* IS_SDLv2 */
+#define pgSurface_Blit                                         \
+    (*(int (*)(PyObject *, PyObject *, SDL_Rect *, SDL_Rect *, \
+               int))PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 2])
+
+#define import_pygame_surface()                   \
+    do {                                          \
+        IMPORT_PYGAME_MODULE(surface, SURFACE);   \
+        if (PyErr_Occurred() != NULL)             \
+            break;                                \
+        IMPORT_PYGAME_MODULE(surflock, SURFLOCK); \
+    } while (0)
+
+#if IS_SDLv2
+#define pgSurface_New(surface) pgSurface_New2((surface), 1)
+#define pgSurface_NewNoOwn(surface) pgSurface_New2((surface), 0)
+#endif /* IS_SDLv2 */
+
+#endif
+
+/* SURFLOCK */ /*auto import/init by surface*/
+#define PYGAMEAPI_SURFLOCK_FIRSTSLOT \
+    (PYGAMEAPI_SURFACE_FIRSTSLOT + PYGAMEAPI_SURFACE_NUMSLOTS)
+#define PYGAMEAPI_SURFLOCK_NUMSLOTS 8
+struct pgSubSurface_Data {
+    PyObject *owner;
+    int pixeloffset;
+    int offsetx, offsety;
+};
+
+typedef struct {
+    PyObject_HEAD PyObject *surface;
+    PyObject *lockobj;
+    PyObject *weakrefs;
+} pgLifetimeLockObject;
+
+#ifndef PYGAMEAPI_SURFLOCK_INTERNAL
+#define pgLifetimeLock_Check(x) \
+    ((x)->ob_type ==            \
+     (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 0])
+#define pgSurface_Prep(x)                   \
+    if (((pgSurfaceObject *)x)->subsurface) \
+    (*(*(void (*)(                          \
+        PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 1]))(x)
+
+#define pgSurface_Unprep(x)                 \
+    if (((pgSurfaceObject *)x)->subsurface) \
+    (*(*(void (*)(                          \
+        PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 2]))(x)
+
+#define pgSurface_Lock \
+    (*(int (*)(PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 3])
+#define pgSurface_Unlock \
+    (*(int (*)(PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 4])
+#define pgSurface_LockBy   \
+    (*(int (*)(PyObject *, \
+               PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 5])
+#define pgSurface_UnlockBy \
+    (*(int (*)(PyObject *, \
+               PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 6])
+#define pgSurface_LockLifetime                 \
+    (*(PyObject * (*)(PyObject *, PyObject *)) \
+         PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 7])
+#endif
+
+/* EVENT */
+#define PYGAMEAPI_EVENT_FIRSTSLOT \
+    (PYGAMEAPI_SURFLOCK_FIRSTSLOT + PYGAMEAPI_SURFLOCK_NUMSLOTS)
+#if IS_SDLv1
+#define PYGAMEAPI_EVENT_NUMSLOTS 4
+#else /* IS_SDLv2 */
+#define PYGAMEAPI_EVENT_NUMSLOTS 6
+#endif /* IS_SDLv2 */
+
+typedef struct {
+    PyObject_HEAD int type;
+    PyObject *dict;
+} pgEventObject;
+
+#ifndef PYGAMEAPI_EVENT_INTERNAL
+#define pgEvent_Check(x) \
+    ((x)->ob_type ==     \
+     (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 0])
+#define pgEvent_Type \
+    (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 0])
+#define pgEvent_New                 \
+    (*(PyObject * (*)(SDL_Event *)) \
+         PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 1])
+#define pgEvent_New2                    \
+    (*(PyObject * (*)(int, PyObject *)) \
+         PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 2])
+#define pgEvent_FillUserEvent   \
+    (*(int (*)(pgEventObject *, \
+               SDL_Event *))PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 3])
+#if IS_SDLv2
+#define pg_EnableKeyRepeat \
+    (*(int (*)(int, int))PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 4])
+#define pg_GetKeyRepeat \
+    (*(void (*)(int *, int *))PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 5])
+#endif /* IS_SDLv2 */
+#define import_pygame_event() IMPORT_PYGAME_MODULE(event, EVENT)
+#endif
+
+/* RWOBJECT */
+/*the rwobject are only needed for C side work, not accessable from python*/
+#define PYGAMEAPI_RWOBJECT_FIRSTSLOT \
+    (PYGAMEAPI_EVENT_FIRSTSLOT + PYGAMEAPI_EVENT_NUMSLOTS)
+#define PYGAMEAPI_RWOBJECT_NUMSLOTS 6
+#ifndef PYGAMEAPI_RWOBJECT_INTERNAL
+#define pgRWops_FromObject           \
+    (*(SDL_RWops * (*)(PyObject *))  \
+         PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 0])
+#define pgRWops_IsFileObject \
+    (*(int (*)(SDL_RWops *))PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 1])
+#define pg_EncodeFilePath                       \
+    (*(PyObject * (*)(PyObject *, PyObject *))  \
+         PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 2])
+#define pg_EncodeString                                                     \
+    (*(PyObject * (*)(PyObject *, const char *, const char *, PyObject *))  \
+         PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 3])
+#define pgRWops_FromFileObject       \
+    (*(SDL_RWops * (*)(PyObject *))  \
+         PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 4])
+#define pgRWops_ReleaseObject       \
+    (*(int (*)(SDL_RWops *))        \
+         PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 5])
+#define import_pygame_rwobject() IMPORT_PYGAME_MODULE(rwobject, RWOBJECT)
+
+#endif
+
+/* PixelArray */
+#define PYGAMEAPI_PIXELARRAY_FIRSTSLOT \
+    (PYGAMEAPI_RWOBJECT_FIRSTSLOT + PYGAMEAPI_RWOBJECT_NUMSLOTS)
+#define PYGAMEAPI_PIXELARRAY_NUMSLOTS 2
+#ifndef PYGAMEAPI_PIXELARRAY_INTERNAL
+#define PyPixelArray_Check(x) \
+    ((x)->ob_type ==          \
+     (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_PIXELARRAY_FIRSTSLOT + 0])
+#define PyPixelArray_New \
+    (*(PyObject * (*)) PyGAME_C_API[PYGAMEAPI_PIXELARRAY_FIRSTSLOT + 1])
+#define import_pygame_pixelarray() IMPORT_PYGAME_MODULE(pixelarray, PIXELARRAY)
+#endif /* PYGAMEAPI_PIXELARRAY_INTERNAL */
+
+/* Color */
+#define PYGAMEAPI_COLOR_FIRSTSLOT \
+    (PYGAMEAPI_PIXELARRAY_FIRSTSLOT + PYGAMEAPI_PIXELARRAY_NUMSLOTS)
+#define PYGAMEAPI_COLOR_NUMSLOTS 4
+#ifndef PYGAMEAPI_COLOR_INTERNAL
+#define pgColor_Check(x) \
+    ((x)->ob_type ==     \
+     (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 0])
+#define pgColor_Type (*(PyObject *)PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT])
+#define pgColor_New \
+    (*(PyObject * (*)(Uint8 *)) PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 1])
+#define pgColor_NewLength              \
+    (*(PyObject * (*)(Uint8 *, Uint8)) \
+         PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 3])
+
+#define pg_RGBAFromColorObj \
+    (*(int (*)(PyObject *,  \
+               Uint8 *))PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 2])
+#define import_pygame_color() IMPORT_PYGAME_MODULE(color, COLOR)
+#endif /* PYGAMEAPI_COLOR_INTERNAL */
+
+/* Math */
+#define PYGAMEAPI_MATH_FIRSTSLOT \
+    (PYGAMEAPI_COLOR_FIRSTSLOT + PYGAMEAPI_COLOR_NUMSLOTS)
+#define PYGAMEAPI_MATH_NUMSLOTS 2
+#ifndef PYGAMEAPI_MATH_INTERNAL
+#define pgVector2_Check(x) \
+    ((x)->ob_type ==       \
+     (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_MATH_FIRSTSLOT + 0])
+#define pgVector3_Check(x) \
+    ((x)->ob_type ==       \
+     (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_MATH_FIRSTSLOT + 1])
+/*
+#define pgVector2_New                                             \
+    (*(PyObject*(*)) PyGAME_C_API[PYGAMEAPI_MATH_FIRSTSLOT + 1])
+*/
+#define import_pygame_math() IMPORT_PYGAME_MODULE(math, MATH)
+#endif /* PYGAMEAPI_MATH_INTERNAL */
+
+#define PG_CAPSULE_NAME(m) (IMPPREFIX m "." PYGAMEAPI_LOCAL_ENTRY)
+
+#define _IMPORT_PYGAME_MODULE(module, MODULE, api_root)                      \
+    {                                                                        \
+        PyObject *_module = PyImport_ImportModule(IMPPREFIX #module);        \
+                                                                             \
+        if (_module != NULL) {                                               \
+            PyObject *_c_api =                                               \
+                PyObject_GetAttrString(_module, PYGAMEAPI_LOCAL_ENTRY);      \
+                                                                             \
+            Py_DECREF(_module);                                              \
+            if (_c_api != NULL && PyCapsule_CheckExact(_c_api)) {            \
+                void **localptr = (void **)PyCapsule_GetPointer(             \
+                    _c_api, PG_CAPSULE_NAME(#module));                       \
+                                                                             \
+                if (localptr != NULL) {                                      \
+                    memcpy(api_root + PYGAMEAPI_##MODULE##_FIRSTSLOT,        \
+                           localptr,                                         \
+                           sizeof(void **) * PYGAMEAPI_##MODULE##_NUMSLOTS); \
+                }                                                            \
+            }                                                                \
+            Py_XDECREF(_c_api);                                              \
+        }                                                                    \
+    }
+
+#ifndef NO_PYGAME_C_API
+#define IMPORT_PYGAME_MODULE(module, MODULE) \
+    _IMPORT_PYGAME_MODULE(module, MODULE, PyGAME_C_API)
+#define PYGAMEAPI_TOTALSLOTS \
+    (PYGAMEAPI_MATH_FIRSTSLOT + PYGAMEAPI_MATH_NUMSLOTS)
+
+#ifdef PYGAME_H
+void *PyGAME_C_API[PYGAMEAPI_TOTALSLOTS] = {NULL};
+#else
+extern void *PyGAME_C_API[PYGAMEAPI_TOTALSLOTS];
+#endif
+#endif
+
+#if PG_HAVE_CAPSULE
+#define encapsulate_api(ptr, module) \
+    PyCapsule_New(ptr, PG_CAPSULE_NAME(module), NULL)
+#else
+#define encapsulate_api(ptr, module) PyCObject_FromVoidPtr(ptr, NULL)
+#endif
+
+#ifndef PG_INLINE
+#if defined(__clang__)
+#define PG_INLINE __inline__ __attribute__((__unused__))
+#elif defined(__GNUC__)
+#define PG_INLINE __inline__
+#elif defined(_MSC_VER)
+#define PG_INLINE __inline
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#define PG_INLINE inline
+#else
+#define PG_INLINE
+#endif
+#endif
+
+/*last platform compiler stuff*/
+#if defined(macintosh) && defined(__MWERKS__) || defined(__SYMBIAN32__)
+#define PYGAME_EXPORT __declspec(export)
+#else
+#define PYGAME_EXPORT
+#endif
+
+
+#endif /* PYGAME_H */

venv/Include/site/python3.7/pygame/_surface.h

@@ -0,0 +1,31 @@
+/*
+  pygame - Python Game Library
+  Copyright (C) 2000-2001  Pete Shinners
+  Copyright (C) 2007 Marcus von Appen
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not, write to the Free
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  Pete Shinners
+  pete@shinners.org
+*/
+
+#ifndef _SURFACE_H
+#define _SURFACE_H
+
+#include "_pygame.h"
+#include "surface.h"
+
+#endif
+

venv/Include/site/python3.7/pygame/bitmask.h

@@ -0,0 +1,146 @@
+/*
+    Bitmask 1.7 - A pixel-perfect collision detection library.
+
+    Copyright (C) 2002-2005 Ulf Ekstrom except for the bitcount
+    function which is copyright (C) Donald W. Gillies, 1992.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef BITMASK_H
+#define BITMASK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <limits.h>
+/* Define INLINE for different compilers.  If your compiler does not
+   support inlining then there might be a performance hit in
+   bitmask_overlap_area().
+*/
+#ifndef INLINE
+# ifdef __GNUC__
+#  define INLINE inline
+# else
+#  ifdef _MSC_VER
+#   define INLINE __inline
+#  else
+#   define INLINE
+#  endif
+# endif
+#endif
+
+#define BITMASK_W unsigned long int
+#define BITMASK_W_LEN (sizeof(BITMASK_W)*CHAR_BIT)
+#define BITMASK_W_MASK (BITMASK_W_LEN - 1)
+#define BITMASK_N(n) ((BITMASK_W)1 << (n))
+
+typedef struct bitmask
+{
+  int w,h;
+  BITMASK_W bits[1];
+} bitmask_t;
+
+/* Creates a bitmask of width w and height h, where
+   w and h must both be greater than or equal to 0.
+   The mask is automatically cleared when created.
+ */
+bitmask_t *bitmask_create(int w, int h);
+
+/* Frees all the memory allocated by bitmask_create for m. */
+void bitmask_free(bitmask_t *m);
+
+/* Clears all bits in the mask */
+void bitmask_clear(bitmask_t *m);
+
+/* Sets all bits in the mask */
+void bitmask_fill(bitmask_t *m);
+
+/* Flips all bits in the mask */
+void bitmask_invert(bitmask_t *m);
+
+/* Counts the bits in the mask */
+unsigned int bitmask_count(bitmask_t *m);
+
+/* Returns nonzero if the bit at (x,y) is set.  Coordinates start at
+   (0,0) */
+static INLINE int bitmask_getbit(const bitmask_t *m, int x, int y)
+{
+  return (m->bits[x/BITMASK_W_LEN*m->h + y] & BITMASK_N(x & BITMASK_W_MASK)) != 0;
+}
+
+/* Sets the bit at (x,y) */
+static INLINE void bitmask_setbit(bitmask_t *m, int x, int y)
+{
+  m->bits[x/BITMASK_W_LEN*m->h + y] |= BITMASK_N(x & BITMASK_W_MASK);
+}
+
+/* Clears the bit at (x,y) */
+static INLINE void bitmask_clearbit(bitmask_t *m, int x, int y)
+{
+  m->bits[x/BITMASK_W_LEN*m->h + y] &= ~BITMASK_N(x & BITMASK_W_MASK);
+}
+
+/* Returns nonzero if the masks overlap with the given offset.
+   The overlap tests uses the following offsets (which may be negative):
+
+   +----+----------..
+   |A   | yoffset
+   |  +-+----------..
+   +--|B
+   |xoffset
+   |  |
+   :  :
+*/
+int bitmask_overlap(const bitmask_t *a, const bitmask_t *b, int xoffset, int yoffset);
+
+/* Like bitmask_overlap(), but will also give a point of intersection.
+   x and y are given in the coordinates of mask a, and are untouched
+   if there is no overlap. */
+int bitmask_overlap_pos(const bitmask_t *a, const bitmask_t *b,
+                        int xoffset, int yoffset, int *x, int *y);
+
+/* Returns the number of overlapping 'pixels' */
+int bitmask_overlap_area(const bitmask_t *a, const bitmask_t *b, int xoffset, int yoffset);
+
+/* Fills a mask with the overlap of two other masks. A bitwise AND. */
+void bitmask_overlap_mask (const bitmask_t *a, const bitmask_t *b, bitmask_t *c, int xoffset, int yoffset);
+
+/* Draws mask b onto mask a (bitwise OR). Can be used to compose large
+   (game background?) mask from several submasks, which may speed up
+   the testing. */
+
+void bitmask_draw(bitmask_t *a, const bitmask_t *b, int xoffset, int yoffset);
+
+void bitmask_erase(bitmask_t *a, const bitmask_t *b, int xoffset, int yoffset);
+
+/* Return a new scaled bitmask, with dimensions w*h. The quality of the
+   scaling may not be perfect for all circumstances, but it should
+   be reasonable. If either w or h is 0 a clear 1x1 mask is returned. */
+bitmask_t *bitmask_scale(const bitmask_t *m, int w, int h);
+
+/* Convolve b into a, drawing the output into o, shifted by offset.  If offset
+ * is 0, then the (x,y) bit will be set if and only if
+ * bitmask_overlap(a, b, x - b->w - 1, y - b->h - 1) returns true.
+ *
+ * Modifies bits o[xoffset ... xoffset + a->w + b->w - 1)
+ *                [yoffset ... yoffset + a->h + b->h - 1). */
+void bitmask_convolve(const bitmask_t *a, const bitmask_t *b, bitmask_t *o, int xoffset, int yoffset);
+
+#ifdef __cplusplus
+} /* End of extern "C" { */
+#endif
+
+#endif

venv/Include/site/python3.7/pygame/camera.h

@@ -0,0 +1,201 @@
+/*
+  pygame - Python Game Library
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not, write to the Free
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include "pygame.h"
+#include "doc/camera_doc.h"
+
+#if defined(__unix__)
+    #include <structmember.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <assert.h>
+
+    #include <fcntl.h>              /* low-level i/o */
+    #include <unistd.h>
+    #include <errno.h>
+    #include <sys/stat.h>
+    #include <sys/types.h>
+    #include <sys/time.h>
+    #include <sys/mman.h>
+    #include <sys/ioctl.h>
+
+    /* on freebsd there is no asm/types */
+    #ifdef linux
+        #include <asm/types.h>          /* for videodev2.h */
+    #endif
+
+    #include <linux/videodev2.h>
+#elif defined(__APPLE__)
+    #include <AvailabilityMacros.h>
+    /* We support OSX 10.6 and below. */
+    #if __MAC_OS_X_VERSION_MAX_ALLOWED <= 1060
+        #define PYGAME_MAC_CAMERA_OLD 1
+    #endif
+#endif
+
+#if defined(PYGAME_MAC_CAMERA_OLD)
+        #include <QuickTime/QuickTime.h>
+        #include <QuickTime/Movies.h>
+        #include <QuickTime/ImageCompression.h>
+#endif
+
+/* some constants used which are not defined on non-v4l machines. */
+#ifndef V4L2_PIX_FMT_RGB24
+    #define V4L2_PIX_FMT_RGB24 'RGB3'
+#endif
+#ifndef V4L2_PIX_FMT_RGB444
+    #define V4L2_PIX_FMT_RGB444 'R444'
+#endif
+#ifndef V4L2_PIX_FMT_YUYV
+    #define V4L2_PIX_FMT_YUYV 'YUYV'
+#endif
+
+#define CLEAR(x) memset (&(x), 0, sizeof (x))
+#define SAT(c) if (c & (~255)) { if (c < 0) c = 0; else c = 255; }
+#define SAT2(c) ((c) & (~255) ? ((c) < 0 ? 0 : 255) : (c))
+#define DEFAULT_WIDTH 640
+#define DEFAULT_HEIGHT 480
+#define RGB_OUT 1
+#define YUV_OUT 2
+#define HSV_OUT 4
+#define CAM_V4L 1 /* deprecated. the incomplete support in pygame was removed */
+#define CAM_V4L2 2
+
+struct buffer {
+    void * start;
+    size_t length;
+};
+
+#if defined(__unix__)
+typedef struct pgCameraObject {
+    PyObject_HEAD
+    char* device_name;
+    int camera_type;
+    unsigned long pixelformat;
+    unsigned int color_out;
+    struct buffer* buffers;
+    unsigned int n_buffers;
+    int width;
+    int height;
+    int size;
+    int hflip;
+    int vflip;
+    int brightness;
+    int fd;
+} pgCameraObject;
+#elif defined(PYGAME_MAC_CAMERA_OLD)
+typedef struct pgCameraObject {
+    PyObject_HEAD
+    char* device_name;              /* unieke name of the device */
+    OSType pixelformat;
+    unsigned int color_out;
+    SeqGrabComponent component;     /* A type used by the Sequence Grabber API */
+    SGChannel channel;              /* Channel of the Sequence Grabber */
+    GWorldPtr gworld;               /* Pointer to the struct that holds the data of the captured image */
+    Rect boundsRect;                /* bounds of the image frame */
+    long size;                      /* size of the image in our buffer to draw */
+    int hflip;
+    int vflip;
+    short depth;
+    struct buffer pixels;
+    //struct buffer tmp_pixels        /* place where the flipped image in temporarly stored if hflip or vflip is true.*/
+} pgCameraObject;
+
+#else
+/* generic definition.
+*/
+
+typedef struct pgCameraObject {
+    PyObject_HEAD
+    char* device_name;
+    int camera_type;
+    unsigned long pixelformat;
+    unsigned int color_out;
+    struct buffer* buffers;
+    unsigned int n_buffers;
+    int width;
+    int height;
+    int size;
+    int hflip;
+    int vflip;
+    int brightness;
+    int fd;
+} pgCameraObject;
+#endif
+
+/* internal functions for colorspace conversion */
+void colorspace (SDL_Surface *src, SDL_Surface *dst, int cspace);
+void rgb24_to_rgb (const void* src, void* dst, int length, SDL_PixelFormat* format);
+void rgb444_to_rgb (const void* src, void* dst, int length, SDL_PixelFormat* format);
+void rgb_to_yuv (const void* src, void* dst, int length,
+                 unsigned long source, SDL_PixelFormat* format);
+void rgb_to_hsv (const void* src, void* dst, int length,
+                 unsigned long source, SDL_PixelFormat* format);
+void yuyv_to_rgb (const void* src, void* dst, int length, SDL_PixelFormat* format);
+void yuyv_to_yuv (const void* src, void* dst, int length, SDL_PixelFormat* format);
+void uyvy_to_rgb (const void* src, void* dst, int length, SDL_PixelFormat* format);
+void uyvy_to_yuv (const void* src, void* dst, int length, SDL_PixelFormat* format);
+void sbggr8_to_rgb (const void* src, void* dst, int width, int height,
+                    SDL_PixelFormat* format);
+void yuv420_to_rgb (const void* src, void* dst, int width, int height,
+                    SDL_PixelFormat* format);
+void yuv420_to_yuv (const void* src, void* dst, int width, int height,
+                    SDL_PixelFormat* format);
+
+#if defined(__unix__)
+/* internal functions specific to v4l2 */
+char** v4l2_list_cameras (int* num_devices);
+int v4l2_get_control (int fd, int id, int *value);
+int v4l2_set_control (int fd, int id, int value);
+PyObject* v4l2_read_raw (pgCameraObject* self);
+int v4l2_xioctl (int fd, int request, void *arg);
+int v4l2_process_image (pgCameraObject* self, const void *image,
+                               unsigned int buffer_size, SDL_Surface* surf);
+int v4l2_query_buffer (pgCameraObject* self);
+int v4l2_read_frame (pgCameraObject* self, SDL_Surface* surf);
+int v4l2_stop_capturing (pgCameraObject* self);
+int v4l2_start_capturing (pgCameraObject* self);
+int v4l2_uninit_device (pgCameraObject* self);
+int v4l2_init_mmap (pgCameraObject* self);
+int v4l2_init_device (pgCameraObject* self);
+int v4l2_close_device (pgCameraObject* self);
+int v4l2_open_device (pgCameraObject* self);
+
+#elif defined(PYGAME_MAC_CAMERA_OLD)
+/* internal functions specific to mac */
+char** mac_list_cameras(int* num_devices);
+int mac_open_device (pgCameraObject* self);
+int mac_init_device(pgCameraObject* self);
+int mac_close_device (pgCameraObject* self);
+int mac_start_capturing(pgCameraObject* self);
+int mac_stop_capturing (pgCameraObject* self);
+
+int mac_get_control(pgCameraObject* self, int id, int* value);
+int mac_set_control(pgCameraObject* self, int id, int value);
+
+PyObject* mac_read_raw(pgCameraObject *self);
+int mac_read_frame(pgCameraObject* self, SDL_Surface* surf);
+int mac_camera_idle(pgCameraObject* self);
+int mac_copy_gworld_to_surface(pgCameraObject* self, SDL_Surface* surf);
+
+void flip_image(const void* image, void* flipped_image, int width, int height,
+                short depth, int hflip, int vflip);
+
+#endif

venv/Include/site/python3.7/pygame/fastevents.h

@@ -0,0 +1,48 @@
+#ifndef _FASTEVENTS_H_
+#define _FASTEVENTS_H_
+/*
+    NET2 is a threaded, event based, network IO library for SDL.
+    Copyright (C) 2002 Bob Pendleton
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public License
+    as published by the Free Software Foundation; either version 2.1
+    of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+    02111-1307 USA
+
+    If you do not wish to comply with the terms of the LGPL please
+    contact the author as other terms are available for a fee.
+
+    Bob Pendleton
+    Bob@Pendleton.com
+*/
+
+#include "SDL.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  int FE_Init(void);                     // Initialize FE
+  void FE_Quit(void);                    // shutdown FE
+
+  void FE_PumpEvents(void);              // replacement for SDL_PumpEvents
+  int FE_PollEvent(SDL_Event *event);    // replacement for SDL_PollEvent
+  int FE_WaitEvent(SDL_Event *event);    // replacement for SDL_WaitEvent
+  int FE_PushEvent(SDL_Event *event);    // replacement for SDL_PushEvent
+
+  char *FE_GetError(void);               // get the last error
+#ifdef __cplusplus
+}
+#endif
+
+#endif

venv/Include/site/python3.7/pygame/font.h

@@ -0,0 +1,57 @@
+/*
+    pygame - Python Game Library
+    Copyright (C) 2000-2001  Pete Shinners
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Pete Shinners
+    pete@shinners.org
+*/
+
+#include <Python.h>
+#if defined(HAVE_SNPRINTF)  /* also defined in SDL_ttf (SDL.h) */
+#undef HAVE_SNPRINTF        /* remove GCC macro redefine warning */
+#endif
+#include <SDL_ttf.h>
+
+
+/* test font initialization */
+#define FONT_INIT_CHECK() \
+    if(!(*(int*)PyFONT_C_API[2])) \
+        return RAISE(pgExc_SDLError, "font system not initialized")
+
+
+
+#define PYGAMEAPI_FONT_FIRSTSLOT 0
+#define PYGAMEAPI_FONT_NUMSLOTS 3
+typedef struct {
+  PyObject_HEAD
+  TTF_Font* font;
+  PyObject* weakreflist;
+} PyFontObject;
+#define PyFont_AsFont(x) (((PyFontObject*)x)->font)
+
+#ifndef PYGAMEAPI_FONT_INTERNAL
+#define PyFont_Check(x) ((x)->ob_type == (PyTypeObject*)PyFONT_C_API[0])
+#define PyFont_Type (*(PyTypeObject*)PyFONT_C_API[0])
+#define PyFont_New (*(PyObject*(*)(TTF_Font*))PyFONT_C_API[1])
+/*slot 2 taken by FONT_INIT_CHECK*/
+
+#define import_pygame_font() \
+    _IMPORT_PYGAME_MODULE(font, FONT, PyFONT_C_API)
+
+static void* PyFONT_C_API[PYGAMEAPI_FONT_NUMSLOTS] = {NULL};
+#endif
+

venv/Include/site/python3.7/pygame/freetype.h

@@ -0,0 +1,137 @@
+/*
+  pygame - Python Game Library
+  Copyright (C) 2009 Vicent Marti
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not, write to the Free
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+#ifndef _PYGAME_FREETYPE_H_
+#define _PYGAME_FREETYPE_H_
+
+#define PGFT_PYGAME1_COMPAT
+#define HAVE_PYGAME_SDL_VIDEO
+#define HAVE_PYGAME_SDL_RWOPS
+
+#include "pygame.h"
+#include "pgcompat.h"
+
+#if PY3
+#   define IS_PYTHON_3
+#endif
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_CACHE_H
+#include FT_XFREE86_H
+#include FT_TRIGONOMETRY_H
+
+/**********************************************************
+ * Global module constants
+ **********************************************************/
+
+/* Render styles */
+#define FT_STYLE_NORMAL     0x00
+#define FT_STYLE_STRONG     0x01
+#define FT_STYLE_OBLIQUE    0x02
+#define FT_STYLE_UNDERLINE  0x04
+#define FT_STYLE_WIDE       0x08
+#define FT_STYLE_DEFAULT    0xFF
+
+/* Bounding box modes */
+#define FT_BBOX_EXACT           FT_GLYPH_BBOX_SUBPIXELS
+#define FT_BBOX_EXACT_GRIDFIT   FT_GLYPH_BBOX_GRIDFIT
+#define FT_BBOX_PIXEL           FT_GLYPH_BBOX_TRUNCATE
+#define FT_BBOX_PIXEL_GRIDFIT   FT_GLYPH_BBOX_PIXELS
+
+/* Rendering flags */
+#define FT_RFLAG_NONE                  (0)
+#define FT_RFLAG_ANTIALIAS             (1 << 0)
+#define FT_RFLAG_AUTOHINT              (1 << 1)
+#define FT_RFLAG_VERTICAL              (1 << 2)
+#define FT_RFLAG_HINTED                (1 << 3)
+#define FT_RFLAG_KERNING               (1 << 4)
+#define FT_RFLAG_TRANSFORM             (1 << 5)
+#define FT_RFLAG_PAD                   (1 << 6)
+#define FT_RFLAG_ORIGIN                (1 << 7)
+#define FT_RFLAG_UCS4                  (1 << 8)
+#define FT_RFLAG_USE_BITMAP_STRIKES    (1 << 9)
+#define FT_RFLAG_DEFAULTS              (FT_RFLAG_HINTED | \
+                                        FT_RFLAG_USE_BITMAP_STRIKES | \
+                                        FT_RFLAG_ANTIALIAS)
+
+
+#define FT_RENDER_NEWBYTEARRAY      0x0
+#define FT_RENDER_NEWSURFACE        0x1
+#define FT_RENDER_EXISTINGSURFACE   0x2
+
+/**********************************************************
+ * Global module types
+ **********************************************************/
+
+typedef struct _scale_s {
+    FT_UInt x, y;
+} Scale_t;
+typedef FT_Angle Angle_t;
+
+struct fontinternals_;
+struct freetypeinstance_;
+
+typedef struct {
+    FT_Long font_index;
+    FT_Open_Args open_args;
+} pgFontId;
+
+typedef struct {
+    PyObject_HEAD
+    pgFontId id;
+    PyObject *path;
+    int is_scalable;
+
+    Scale_t face_size;
+    FT_Int16 style;
+    FT_Int16 render_flags;
+    double strength;
+    double underline_adjustment;
+    FT_UInt resolution;
+    Angle_t rotation;
+    FT_Matrix transform;
+    FT_Byte fgcolor[4];
+
+    struct freetypeinstance_ *freetype;  /* Personal reference */
+    struct fontinternals_ *_internals;
+} pgFontObject;
+
+#define pgFont_IS_ALIVE(o) \
+    (((pgFontObject *)(o))->_internals != 0)
+
+/**********************************************************
+ * Module declaration
+ **********************************************************/
+#define PYGAMEAPI_FREETYPE_FIRSTSLOT 0
+#define PYGAMEAPI_FREETYPE_NUMSLOTS 2
+
+#ifndef PYGAME_FREETYPE_INTERNAL
+
+#define pgFont_Check(x) ((x)->ob_type == (PyTypeObject*)PgFREETYPE_C_API[0])
+#define pgFont_Type (*(PyTypeObject*)PgFREETYPE_C_API[1])
+#define pgFont_New (*(PyObject*(*)(const char*, long))PgFREETYPE_C_API[1])
+
+#define import_pygame_freetype() \
+    _IMPORT_PYGAME_MODULE(freetype, FREETYPE, PgFREETYPE_C_API)
+
+static void *PgFREETYPE_C_API[PYGAMEAPI_FREETYPE_NUMSLOTS] = {0};
+#endif /* PYGAME_FREETYPE_INTERNAL */
+
+#endif /* _PYGAME_FREETYPE_H_ */

venv/Include/site/python3.7/pygame/mask.h

@@ -0,0 +1,25 @@
+#include <Python.h>
+#include "bitmask.h"
+
+#define PYGAMEAPI_MASK_FIRSTSLOT 0
+#define PYGAMEAPI_MASK_NUMSLOTS 1
+#define PYGAMEAPI_LOCAL_ENTRY "_PYGAME_C_API"
+
+typedef struct {
+  PyObject_HEAD
+  bitmask_t *mask;
+} pgMaskObject;
+
+#define pgMask_AsBitmap(x) (((pgMaskObject*)x)->mask)
+
+#ifndef PYGAMEAPI_MASK_INTERNAL
+
+#define pgMask_Type     (*(PyTypeObject*)PyMASK_C_API[0])
+#define pgMask_Check(x) ((x)->ob_type == &pgMask_Type)
+
+#define import_pygame_mask() \
+    _IMPORT_PYGAME_MODULE(mask, MASK, PyMASK_C_API)
+
+static void* PyMASK_C_API[PYGAMEAPI_MASK_NUMSLOTS] = {NULL};
+#endif /* #ifndef PYGAMEAPI_MASK_INTERNAL */
+

venv/Include/site/python3.7/pygame/mixer.h

@@ -0,0 +1,65 @@
+/*
+    pygame - Python Game Library
+    Copyright (C) 2000-2001  Pete Shinners
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Pete Shinners
+    pete@shinners.org
+*/
+
+#include <Python.h>
+#include <SDL_mixer.h>
+#include <structmember.h>
+
+
+/* test mixer initializations */
+#define MIXER_INIT_CHECK() \
+    if(!SDL_WasInit(SDL_INIT_AUDIO)) \
+        return RAISE(pgExc_SDLError, "mixer not initialized")
+
+
+#define PYGAMEAPI_MIXER_FIRSTSLOT 0
+#define PYGAMEAPI_MIXER_NUMSLOTS 7
+typedef struct {
+  PyObject_HEAD
+  Mix_Chunk *chunk;
+  Uint8 *mem;
+  PyObject *weakreflist;
+} pgSoundObject;
+typedef struct {
+  PyObject_HEAD
+  int chan;
+} pgChannelObject;
+#define pgSound_AsChunk(x) (((pgSoundObject*)x)->chunk)
+#define pgChannel_AsInt(x) (((pgChannelObject*)x)->chan)
+
+#ifndef PYGAMEAPI_MIXER_INTERNAL
+#define pgSound_Check(x) ((x)->ob_type == (PyTypeObject*)pgMIXER_C_API[0])
+#define pgSound_Type (*(PyTypeObject*)pgMIXER_C_API[0])
+#define pgSound_New (*(PyObject*(*)(Mix_Chunk*))pgMIXER_C_API[1])
+#define pgSound_Play (*(PyObject*(*)(PyObject*, PyObject*))pgMIXER_C_API[2])
+#define pgChannel_Check(x) ((x)->ob_type == (PyTypeObject*)pgMIXER_C_API[3])
+#define pgChannel_Type (*(PyTypeObject*)pgMIXER_C_API[3])
+#define pgChannel_New (*(PyObject*(*)(int))pgMIXER_C_API[4])
+#define pgMixer_AutoInit (*(PyObject*(*)(PyObject*, PyObject*))pgMIXER_C_API[5])
+#define pgMixer_AutoQuit (*(void(*)(void))pgMIXER_C_API[6])
+
+#define import_pygame_mixer() \
+    _IMPORT_PYGAME_MODULE(mixer, MIXER, pgMIXER_C_API)
+
+static void* pgMIXER_C_API[PYGAMEAPI_MIXER_NUMSLOTS] = {NULL};
+#endif
+

venv/Include/site/python3.7/pygame/palette.h

@@ -0,0 +1,123 @@
+/*
+    pygame - Python Game Library
+    Copyright (C) 2000-2001  Pete Shinners
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Pete Shinners
+    pete@shinners.org
+*/
+
+#ifndef PALETTE_H
+#define PALETTE_H
+
+#include <SDL.h>
+
+/* SDL 2 does not assign a default palette color scheme to a new 8 bit
+ * surface. Instead, the palette is set all white. This defines the SDL 1.2
+ * default palette.
+ */
+static const SDL_Color default_palette_colors[] = {
+    {0, 0, 0, 255},       {0, 0, 85, 255},      {0, 0, 170, 255},
+    {0, 0, 255, 255},     {0, 36, 0, 255},      {0, 36, 85, 255},
+    {0, 36, 170, 255},    {0, 36, 255, 255},    {0, 73, 0, 255},
+    {0, 73, 85, 255},     {0, 73, 170, 255},    {0, 73, 255, 255},
+    {0, 109, 0, 255},     {0, 109, 85, 255},    {0, 109, 170, 255},
+    {0, 109, 255, 255},   {0, 146, 0, 255},     {0, 146, 85, 255},
+    {0, 146, 170, 255},   {0, 146, 255, 255},   {0, 182, 0, 255},
+    {0, 182, 85, 255},    {0, 182, 170, 255},   {0, 182, 255, 255},
+    {0, 219, 0, 255},     {0, 219, 85, 255},    {0, 219, 170, 255},
+    {0, 219, 255, 255},   {0, 255, 0, 255},     {0, 255, 85, 255},
+    {0, 255, 170, 255},   {0, 255, 255, 255},   {85, 0, 0, 255},
+    {85, 0, 85, 255},     {85, 0, 170, 255},    {85, 0, 255, 255},
+    {85, 36, 0, 255},     {85, 36, 85, 255},    {85, 36, 170, 255},
+    {85, 36, 255, 255},   {85, 73, 0, 255},     {85, 73, 85, 255},
+    {85, 73, 170, 255},   {85, 73, 255, 255},   {85, 109, 0, 255},
+    {85, 109, 85, 255},   {85, 109, 170, 255},  {85, 109, 255, 255},
+    {85, 146, 0, 255},    {85, 146, 85, 255},   {85, 146, 170, 255},
+    {85, 146, 255, 255},  {85, 182, 0, 255},    {85, 182, 85, 255},
+    {85, 182, 170, 255},  {85, 182, 255, 255},  {85, 219, 0, 255},
+    {85, 219, 85, 255},   {85, 219, 170, 255},  {85, 219, 255, 255},
+    {85, 255, 0, 255},    {85, 255, 85, 255},   {85, 255, 170, 255},
+    {85, 255, 255, 255},  {170, 0, 0, 255},     {170, 0, 85, 255},
+    {170, 0, 170, 255},   {170, 0, 255, 255},   {170, 36, 0, 255},
+    {170, 36, 85, 255},   {170, 36, 170, 255},  {170, 36, 255, 255},
+    {170, 73, 0, 255},    {170, 73, 85, 255},   {170, 73, 170, 255},
+    {170, 73, 255, 255},  {170, 109, 0, 255},   {170, 109, 85, 255},
+    {170, 109, 170, 255}, {170, 109, 255, 255}, {170, 146, 0, 255},
+    {170, 146, 85, 255},  {170, 146, 170, 255}, {170, 146, 255, 255},
+    {170, 182, 0, 255},   {170, 182, 85, 255},  {170, 182, 170, 255},
+    {170, 182, 255, 255}, {170, 219, 0, 255},   {170, 219, 85, 255},
+    {170, 219, 170, 255}, {170, 219, 255, 255}, {170, 255, 0, 255},
+    {170, 255, 85, 255},  {170, 255, 170, 255}, {170, 255, 255, 255},
+    {255, 0, 0, 255},     {255, 0, 85, 255},    {255, 0, 170, 255},
+    {255, 0, 255, 255},   {255, 36, 0, 255},    {255, 36, 85, 255},
+    {255, 36, 170, 255},  {255, 36, 255, 255},  {255, 73, 0, 255},
+    {255, 73, 85, 255},   {255, 73, 170, 255},  {255, 73, 255, 255},
+    {255, 109, 0, 255},   {255, 109, 85, 255},  {255, 109, 170, 255},
+    {255, 109, 255, 255}, {255, 146, 0, 255},   {255, 146, 85, 255},
+    {255, 146, 170, 255}, {255, 146, 255, 255}, {255, 182, 0, 255},
+    {255, 182, 85, 255},  {255, 182, 170, 255}, {255, 182, 255, 255},
+    {255, 219, 0, 255},   {255, 219, 85, 255},  {255, 219, 170, 255},
+    {255, 219, 255, 255}, {255, 255, 0, 255},   {255, 255, 85, 255},
+    {255, 255, 170, 255}, {255, 255, 255, 255}, {0, 0, 0, 255},
+    {0, 0, 85, 255},      {0, 0, 170, 255},     {0, 0, 255, 255},
+    {0, 36, 0, 255},      {0, 36, 85, 255},     {0, 36, 170, 255},
+    {0, 36, 255, 255},    {0, 73, 0, 255},      {0, 73, 85, 255},
+    {0, 73, 170, 255},    {0, 73, 255, 255},    {0, 109, 0, 255},
+    {0, 109, 85, 255},    {0, 109, 170, 255},   {0, 109, 255, 255},
+    {0, 146, 0, 255},     {0, 146, 85, 255},    {0, 146, 170, 255},
+    {0, 146, 255, 255},   {0, 182, 0, 255},     {0, 182, 85, 255},
+    {0, 182, 170, 255},   {0, 182, 255, 255},   {0, 219, 0, 255},
+    {0, 219, 85, 255},    {0, 219, 170, 255},   {0, 219, 255, 255},
+    {0, 255, 0, 255},     {0, 255, 85, 255},    {0, 255, 170, 255},
+    {0, 255, 255, 255},   {85, 0, 0, 255},      {85, 0, 85, 255},
+    {85, 0, 170, 255},    {85, 0, 255, 255},    {85, 36, 0, 255},
+    {85, 36, 85, 255},    {85, 36, 170, 255},   {85, 36, 255, 255},
+    {85, 73, 0, 255},     {85, 73, 85, 255},    {85, 73, 170, 255},
+    {85, 73, 255, 255},   {85, 109, 0, 255},    {85, 109, 85, 255},
+    {85, 109, 170, 255},  {85, 109, 255, 255},  {85, 146, 0, 255},
+    {85, 146, 85, 255},   {85, 146, 170, 255},  {85, 146, 255, 255},
+    {85, 182, 0, 255},    {85, 182, 85, 255},   {85, 182, 170, 255},
+    {85, 182, 255, 255},  {85, 219, 0, 255},    {85, 219, 85, 255},
+    {85, 219, 170, 255},  {85, 219, 255, 255},  {85, 255, 0, 255},
+    {85, 255, 85, 255},   {85, 255, 170, 255},  {85, 255, 255, 255},
+    {170, 0, 0, 255},     {170, 0, 85, 255},    {170, 0, 170, 255},
+    {170, 0, 255, 255},   {170, 36, 0, 255},    {170, 36, 85, 255},
+    {170, 36, 170, 255},  {170, 36, 255, 255},  {170, 73, 0, 255},
+    {170, 73, 85, 255},   {170, 73, 170, 255},  {170, 73, 255, 255},
+    {170, 109, 0, 255},   {170, 109, 85, 255},  {170, 109, 170, 255},
+    {170, 109, 255, 255}, {170, 146, 0, 255},   {170, 146, 85, 255},
+    {170, 146, 170, 255}, {170, 146, 255, 255}, {170, 182, 0, 255},
+    {170, 182, 85, 255},  {170, 182, 170, 255}, {170, 182, 255, 255},
+    {170, 219, 0, 255},   {170, 219, 85, 255},  {170, 219, 170, 255},
+    {170, 219, 255, 255}, {170, 255, 0, 255},   {170, 255, 85, 255},
+    {170, 255, 170, 255}, {170, 255, 255, 255}, {255, 0, 0, 255},
+    {255, 0, 85, 255},    {255, 0, 170, 255},   {255, 0, 255, 255},
+    {255, 36, 0, 255},    {255, 36, 85, 255},   {255, 36, 170, 255},
+    {255, 36, 255, 255},  {255, 73, 0, 255},    {255, 73, 85, 255},
+    {255, 73, 170, 255},  {255, 73, 255, 255},  {255, 109, 0, 255},
+    {255, 109, 85, 255},  {255, 109, 170, 255}, {255, 109, 255, 255},
+    {255, 146, 0, 255},   {255, 146, 85, 255},  {255, 146, 170, 255},
+    {255, 146, 255, 255}, {255, 182, 0, 255},   {255, 182, 85, 255},
+    {255, 182, 170, 255}, {255, 182, 255, 255}, {255, 219, 0, 255},
+    {255, 219, 85, 255},  {255, 219, 170, 255}, {255, 219, 255, 255},
+    {255, 255, 0, 255},   {255, 255, 85, 255},  {255, 255, 170, 255},
+    {255, 255, 255, 255}};
+
+static const int default_palette_size =
+    (int)(sizeof(default_palette_colors) / sizeof(SDL_Color));
+
+#endif

venv/Include/site/python3.7/pygame/pgarrinter.h

@@ -0,0 +1,26 @@
+/* array structure interface version 3 declarations */
+
+#if !defined(PG_ARRAYINTER_HEADER)
+#define PG_ARRAYINTER_HEADER
+
+static const int PAI_CONTIGUOUS = 0x01;
+static const int PAI_FORTRAN = 0x02;
+static const int PAI_ALIGNED = 0x100;
+static const int PAI_NOTSWAPPED = 0x200;
+static const int PAI_WRITEABLE = 0x400;
+static const int PAI_ARR_HAS_DESCR = 0x800;
+
+typedef struct {
+    int two;              /* contains the integer 2 -- simple sanity check */
+    int nd;               /* number of dimensions */
+    char typekind;        /* kind in array -- character code of typestr */
+    int itemsize;         /* size of each element */
+    int flags;            /* flags indicating how the data should be */
+                          /* interpreted */
+    Py_intptr_t *shape;   /* A length-nd array of shape information */
+    Py_intptr_t *strides; /* A length-nd array of stride information */
+    void *data;           /* A pointer to the first element of the array */
+    PyObject *descr;      /* NULL or a data-description */
+} PyArrayInterface;
+
+#endif

venv/Include/site/python3.7/pygame/pgbufferproxy.h

@@ -0,0 +1,52 @@
+/*
+  pygame - Python Game Library
+  Copyright (C) 2000-2001  Pete Shinners
+  Copyright (C) 2007  Rene Dudfield, Richard Goedeken
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not, write to the Free
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  Pete Shinners
+  pete@shinners.org
+*/
+
+/* Bufferproxy module C api.
+   Depends on pygame.h being included first.
+ */
+#if !defined(PG_BUFPROXY_HEADER)
+
+#define PYGAMEAPI_BUFPROXY_NUMSLOTS 4
+#define PYGAMEAPI_BUFPROXY_FIRSTSLOT 0
+
+#if !(defined(PYGAMEAPI_BUFPROXY_INTERNAL) || defined(NO_PYGAME_C_API))
+static void *PgBUFPROXY_C_API[PYGAMEAPI_BUFPROXY_NUMSLOTS];
+
+typedef PyObject *(*_pgbufproxy_new_t)(PyObject *, getbufferproc);
+typedef PyObject *(*_pgbufproxy_get_obj_t)(PyObject *);
+typedef int (*_pgbufproxy_trip_t)(PyObject *);
+
+#define pgBufproxy_Type (*(PyTypeObject*)PgBUFPROXY_C_API[0])
+#define pgBufproxy_New (*(_pgbufproxy_new_t)PgBUFPROXY_C_API[1])
+#define pgBufproxy_GetParent \
+    (*(_pgbufproxy_get_obj_t)PgBUFPROXY_C_API[2])
+#define pgBufproxy_Trip (*(_pgbufproxy_trip_t)PgBUFPROXY_C_API[3])
+#define pgBufproxy_Check(x) ((x)->ob_type == (pgBufproxy_Type))
+#define import_pygame_bufferproxy() \
+    _IMPORT_PYGAME_MODULE(bufferproxy, BUFPROXY, PgBUFPROXY_C_API)
+
+#endif /* #if !(defined(PYGAMEAPI_BUFPROXY_INTERNAL) || ... */
+
+#define PG_BUFPROXY_HEADER
+
+#endif /* #if !defined(PG_BUFPROXY_HEADER) */

venv/Include/site/python3.7/pygame/pgcompat.h

@@ -0,0 +1,195 @@
+/* Python 2.x/3.x compitibility tools
+ */
+
+#if !defined(PGCOMPAT_H)
+#define PGCOMPAT_H
+
+#if PY_MAJOR_VERSION >= 3
+
+#define PY3 1
+
+/* Define some aliases for the removed PyInt_* functions */
+#define PyInt_Check(op) PyLong_Check(op)
+#define PyInt_FromString PyLong_FromString
+#define PyInt_FromUnicode PyLong_FromUnicode
+#define PyInt_FromLong PyLong_FromLong
+#define PyInt_FromSize_t PyLong_FromSize_t
+#define PyInt_FromSsize_t PyLong_FromSsize_t
+#define PyInt_AsLong PyLong_AsLong
+#define PyInt_AsSsize_t PyLong_AsSsize_t
+#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
+#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+#define PyInt_AS_LONG PyLong_AS_LONG
+#define PyNumber_Int PyNumber_Long
+
+/* Weakrefs flags changed in 3.x */
+#define Py_TPFLAGS_HAVE_WEAKREFS 0
+
+/* Module init function returns new module instance. */
+#define MODINIT_RETURN(x) return x
+#define MODINIT_DEFINE(mod_name) PyMODINIT_FUNC PyInit_##mod_name (void)
+#define DECREF_MOD(mod) Py_DECREF (mod)
+
+/* Type header differs. */
+#define TYPE_HEAD(x,y) PyVarObject_HEAD_INIT(x,y)
+
+/* Text interface. Use unicode strings. */
+#define Text_Type PyUnicode_Type
+#define Text_Check PyUnicode_Check
+
+#ifndef PYPY_VERSION
+#define Text_FromLocale(s) PyUnicode_DecodeLocale((s), "strict")
+#else /* PYPY_VERSION */
+/* workaround: missing function for pypy */
+#define Text_FromLocale PyUnicode_FromString
+#endif /* PYPY_VERSION */
+
+#define Text_FromUTF8 PyUnicode_FromString
+#define Text_FromUTF8AndSize PyUnicode_FromStringAndSize
+#define Text_FromFormat PyUnicode_FromFormat
+#define Text_GetSize PyUnicode_GetSize
+#define Text_GET_SIZE PyUnicode_GET_SIZE
+
+/* Binary interface. Use bytes. */
+#define Bytes_Type PyBytes_Type
+#define Bytes_Check PyBytes_Check
+#define Bytes_Size PyBytes_Size
+#define Bytes_AsString PyBytes_AsString
+#define Bytes_AsStringAndSize PyBytes_AsStringAndSize
+#define Bytes_FromStringAndSize PyBytes_FromStringAndSize
+#define Bytes_FromFormat PyBytes_FromFormat
+#define Bytes_AS_STRING PyBytes_AS_STRING
+#define Bytes_GET_SIZE PyBytes_GET_SIZE
+#define Bytes_AsDecodeObject PyBytes_AsDecodedObject
+
+#define Object_Unicode PyObject_Str
+
+#define IsTextObj(x) (PyUnicode_Check(x) || PyBytes_Check(x))
+
+/* Renamed builtins */
+#define BUILTINS_MODULE "builtins"
+#define BUILTINS_UNICODE "str"
+#define BUILTINS_UNICHR "chr"
+
+/* Defaults for unicode file path encoding */
+#define UNICODE_DEF_FS_CODEC Py_FileSystemDefaultEncoding
+#if defined(MS_WIN32)
+#define UNICODE_DEF_FS_ERROR "replace"
+#else
+#define UNICODE_DEF_FS_ERROR "surrogateescape"
+#endif
+
+#else /* #if PY_MAJOR_VERSION >= 3 */
+
+#define PY3 0
+
+/* Module init function returns nothing. */
+#define MODINIT_RETURN(x) return
+#define MODINIT_DEFINE(mod_name) PyMODINIT_FUNC init##mod_name (void)
+#define DECREF_MOD(mod)
+
+/* Type header differs. */
+#define TYPE_HEAD(x,y)                          \
+    PyObject_HEAD_INIT(x)                       \
+    0,
+
+/* Text interface. Use ascii strings. */
+#define Text_Type PyString_Type
+#define Text_Check PyString_Check
+#define Text_FromLocale PyString_FromString
+#define Text_FromUTF8 PyString_FromString
+#define Text_FromUTF8AndSize PyString_FromStringAndSize
+#define Text_FromFormat PyString_FromFormat
+#define Text_GetSize PyString_GetSize
+#define Text_GET_SIZE PyString_GET_SIZE
+
+/* Binary interface. Use ascii strings. */
+#define Bytes_Type PyString_Type
+#define Bytes_Check PyString_Check
+#define Bytes_Size PyString_Size
+#define Bytes_AsString PyString_AsString
+#define Bytes_AsStringAndSize PyString_AsStringAndSize
+#define Bytes_FromStringAndSize PyString_FromStringAndSize
+#define Bytes_FromFormat PyString_FromFormat
+#define Bytes_AS_STRING PyString_AS_STRING
+#define Bytes_GET_SIZE PyString_GET_SIZE
+#define Bytes_AsDecodedObject PyString_AsDecodedObject
+
+#define Object_Unicode PyObject_Unicode
+
+/* Renamed builtins */
+#define BUILTINS_MODULE "__builtin__"
+#define BUILTINS_UNICODE "unicode"
+#define BUILTINS_UNICHR "unichr"
+
+/* Defaults for unicode file path encoding */
+#define UNICODE_DEF_FS_CODEC Py_FileSystemDefaultEncoding
+#define UNICODE_DEF_FS_ERROR "strict"
+
+#endif /* #if PY_MAJOR_VERSION >= 3 */
+
+#define PY2 (!PY3)
+
+#define MODINIT_ERROR MODINIT_RETURN (NULL)
+
+/* Module state. These macros are used to define per-module macros.
+ * v - global state variable (Python 2.x)
+ * s - global state structure (Python 3.x)
+ */
+#define PY2_GETSTATE(v) (&(v))
+#define PY3_GETSTATE(s, m) ((struct s *) PyModule_GetState (m))
+
+/* Pep 3123: Making PyObject_HEAD conform to standard C */
+#if !defined(Py_TYPE)
+#define Py_TYPE(o)    (((PyObject *)(o))->ob_type)
+#define Py_REFCNT(o)  (((PyObject *)(o))->ob_refcnt)
+#define Py_SIZE(o)    (((PyVarObject *)(o))->ob_size)
+#endif
+
+/* Encode a unicode file path */
+#define Unicode_AsEncodedPath(u) \
+    PyUnicode_AsEncodedString ((u), UNICODE_DEF_FS_CODEC, UNICODE_DEF_FS_ERROR)
+
+#define RELATIVE_MODULE(m) ("." m)
+
+#define HAVE_OLD_BUFPROTO PY2
+
+#if !defined(PG_ENABLE_OLDBUF)  /* allow for command line override */
+#if HAVE_OLD_BUFPROTO
+#define PG_ENABLE_OLDBUF 1
+#else
+#define PG_ENABLE_OLDBUF 0
+#endif
+#endif
+
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+#define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+
+#ifndef Py_TPFLAGS_HAVE_CLASS
+#define Py_TPFLAGS_HAVE_CLASS 0
+#endif
+
+#ifndef Py_TPFLAGS_CHECKTYPES
+#define Py_TPFLAGS_CHECKTYPES 0
+#endif
+
+#if PY_VERSION_HEX >= 0x03020000
+#define Slice_GET_INDICES_EX(slice, length, start, stop, step, slicelength) \
+    PySlice_GetIndicesEx(slice, length, start, stop, step, slicelength)
+#else
+#define Slice_GET_INDICES_EX(slice, length, start, stop, step, slicelength) \
+    PySlice_GetIndicesEx((PySliceObject *)(slice), length, \
+                         start, stop, step, slicelength)
+#endif
+
+/* Support new buffer protocol? */
+#if !defined(PG_ENABLE_NEWBUF)  /* allow for command line override */
+#if !defined(PYPY_VERSION)
+#define PG_ENABLE_NEWBUF 1
+#else
+#define PG_ENABLE_NEWBUF 0
+#endif
+#endif
+
+#endif /* #if !defined(PGCOMPAT_H) */

venv/Include/site/python3.7/pygame/pgopengl.h

@@ -0,0 +1,16 @@
+#if !defined(PGOPENGL_H)
+#define PGOPENGL_H
+
+/** This header includes definitions of Opengl functions as pointer types for
+ ** use with the SDL function SDL_GL_GetProcAddress.
+ **/
+
+#if defined(_WIN32)
+#define GL_APIENTRY __stdcall
+#else
+#define GL_APIENTRY
+#endif
+
+typedef void (GL_APIENTRY *GL_glReadPixels_Func)(int, int, int, int, unsigned int, unsigned int, void*);
+
+#endif

venv/Include/site/python3.7/pygame/pygame.h

@@ -0,0 +1,34 @@
+/*
+    pygame - Python Game Library
+    Copyright (C) 2000-2001  Pete Shinners
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Pete Shinners
+    pete@shinners.org
+*/
+
+/* To allow the Pygame C api to be globally shared by all code within an
+ * extension module built from multiple C files,  only include the pygame.h
+ * header within the top level C file, the one which calls the
+ * 'import_pygame_*' macros. All other C source files of the module should
+ * include _pygame.h instead. 
+ */
+#ifndef PYGAME_H
+#define PYGAME_H
+
+#include "_pygame.h"
+
+#endif

venv/Include/site/python3.7/pygame/scrap.h

@@ -0,0 +1,143 @@
+/*
+    pygame - Python Game Library
+    Copyright (C) 2006, 2007 Rene Dudfield, Marcus von Appen
+
+    Originally put in the public domain by Sam Lantinga.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+/* This is unconditionally defined in Python.h */
+#if defined(_POSIX_C_SOURCE)
+#undef _POSIX_C_SOURCE
+#endif
+
+#include <Python.h>
+
+/* Handle clipboard text and data in arbitrary formats */
+
+/**
+ * Predefined supported pygame scrap types.
+ */
+#define PYGAME_SCRAP_TEXT "text/plain"
+#define PYGAME_SCRAP_BMP "image/bmp"
+#define PYGAME_SCRAP_PPM "image/ppm"
+#define PYGAME_SCRAP_PBM "image/pbm"
+
+/**
+ * The supported scrap clipboard types.
+ *
+ * This is only relevant in a X11 environment, which supports mouse
+ * selections as well. For Win32 and MacOS environments the default
+ * clipboard is used, no matter what value is passed.
+ */
+typedef enum
+{
+    SCRAP_CLIPBOARD,
+    SCRAP_SELECTION /* only supported in X11 environments. */
+} ScrapClipType;
+
+/**
+ * Macro for initialization checks.
+ */
+#define PYGAME_SCRAP_INIT_CHECK() \
+    if(!pygame_scrap_initialized()) \
+        return (PyErr_SetString (pgExc_SDLError, \
+                                 "scrap system not initialized."), NULL)
+
+/**
+ * \brief Checks, whether the pygame scrap module was initialized.
+ *
+ * \return 1 if the modules was initialized, 0 otherwise.
+ */
+extern int
+pygame_scrap_initialized (void);
+
+/**
+ * \brief Initializes the pygame scrap module internals. Call this before any
+ *        other method.
+ *
+ * \return 1 on successful initialization, 0 otherwise.
+ */
+extern int
+pygame_scrap_init (void);
+
+/**
+ * \brief Checks, whether the pygame window lost the clipboard focus or not.
+ *
+ * \return 1 if the window lost the focus, 0 otherwise.
+ */
+extern int
+pygame_scrap_lost (void);
+
+/**
+ * \brief Places content of a specific type into the clipboard.
+ *
+ * \note For X11 the following notes are important: The following types
+ *       are reserved for internal usage and thus will throw an error on
+ *       setting them: "TIMESTAMP", "TARGETS", "SDL_SELECTION".
+ *       Setting PYGAME_SCRAP_TEXT ("text/plain") will also automatically
+ *       set the X11 types "STRING" (XA_STRING), "TEXT" and "UTF8_STRING".
+ *
+ *       For Win32 the following notes are important: Setting
+ *       PYGAME_SCRAP_TEXT ("text/plain") will also automatically set
+ *       the Win32 type "TEXT" (CF_TEXT).
+ *
+ *       For QNX the following notes are important: Setting
+ *       PYGAME_SCRAP_TEXT ("text/plain") will also automatically set
+ *       the QNX type "TEXT" (Ph_CL_TEXT).
+ *
+ * \param type The type of the content.
+ * \param srclen The length of the content.
+ * \param src The NULL terminated content.
+ * \return 1, if the content could be successfully pasted into the clipboard,
+ *         0 otherwise.
+ */
+extern int
+pygame_scrap_put (char *type, int srclen, char *src);
+
+/**
+ * \brief Gets the current content from the clipboard.
+ *
+ * \note The received content does not need to be the content previously
+ *       placed in the clipboard using pygame_put_scrap(). See the
+ *       pygame_put_scrap() notes for more details.
+ *
+ * \param type The type of the content to receive.
+ * \param count The size of the returned content.
+ * \return The content or NULL in case of an error or if no content of the
+ *         specified type was available.
+ */
+extern char*
+pygame_scrap_get (char *type, unsigned long *count);
+
+/**
+ * \brief Gets the currently available content types from the clipboard.
+ *
+ * \return The different available content types or NULL in case of an
+ *         error or if no content type is available.
+ */
+extern char**
+pygame_scrap_get_types (void);
+
+/**
+ * \brief Checks whether content for the specified scrap type is currently
+ * available in the clipboard.
+ *
+ * \param type The type to check for.
+ * \return 1, if there is content and 0 otherwise.
+ */
+extern int
+pygame_scrap_contains (char *type);

venv/Include/site/python3.7/pygame/surface.h

@@ -0,0 +1,383 @@
+/*
+  pygame - Python Game Library
+  Copyright (C) 2000-2001  Pete Shinners
+  Copyright (C) 2007 Marcus von Appen
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not, write to the Free
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  Pete Shinners
+  pete@shinners.org
+*/
+
+#ifndef SURFACE_H
+#define SURFACE_H
+
+/* This is defined in SDL.h */
+#if defined(_POSIX_C_SOURCE)
+#undef _POSIX_C_SOURCE
+#endif
+
+#include <SDL.h>
+#include "pygame.h"
+
+/* Blend modes */
+#define PYGAME_BLEND_ADD  0x1
+#define PYGAME_BLEND_SUB  0x2
+#define PYGAME_BLEND_MULT 0x3
+#define PYGAME_BLEND_MIN  0x4
+#define PYGAME_BLEND_MAX  0x5
+
+#define PYGAME_BLEND_RGB_ADD  0x1
+#define PYGAME_BLEND_RGB_SUB  0x2
+#define PYGAME_BLEND_RGB_MULT 0x3
+#define PYGAME_BLEND_RGB_MIN  0x4
+#define PYGAME_BLEND_RGB_MAX  0x5
+
+#define PYGAME_BLEND_RGBA_ADD  0x6
+#define PYGAME_BLEND_RGBA_SUB  0x7
+#define PYGAME_BLEND_RGBA_MULT 0x8
+#define PYGAME_BLEND_RGBA_MIN  0x9
+#define PYGAME_BLEND_RGBA_MAX  0x10
+#define PYGAME_BLEND_PREMULTIPLIED  0x11
+
+
+
+
+
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+#define GET_PIXEL_24(b) (b[0] + (b[1] << 8) + (b[2] << 16))
+#else
+#define GET_PIXEL_24(b) (b[2] + (b[1] << 8) + (b[0] << 16))
+#endif
+
+#define GET_PIXEL(pxl, bpp, source)               \
+    switch (bpp)                                  \
+    {                                             \
+    case 2:                                       \
+        pxl = *((Uint16 *) (source));             \
+        break;                                    \
+    case 4:                                       \
+        pxl = *((Uint32 *) (source));             \
+        break;                                    \
+    default:                                      \
+    {                                             \
+        Uint8 *b = (Uint8 *) source;              \
+        pxl = GET_PIXEL_24(b);                    \
+    }                                             \
+    break;                                        \
+    }
+
+#if IS_SDLv1
+#define GET_PIXELVALS(_sR, _sG, _sB, _sA, px, fmt, ppa)               \
+    _sR = ((px & fmt->Rmask) >> fmt->Rshift);                         \
+    _sR = (_sR << fmt->Rloss) + (_sR >> (8 - (fmt->Rloss << 1)));     \
+    _sG = ((px & fmt->Gmask) >> fmt->Gshift);                         \
+    _sG = (_sG << fmt->Gloss) + (_sG >> (8 - (fmt->Gloss << 1)));     \
+    _sB = ((px & fmt->Bmask) >> fmt->Bshift);                         \
+    _sB = (_sB << fmt->Bloss) + (_sB >> (8 - (fmt->Bloss << 1)));     \
+    if (ppa)                                                          \
+    {                                                                 \
+        _sA = ((px & fmt->Amask) >> fmt->Ashift);                     \
+        _sA = (_sA << fmt->Aloss) + (_sA >> (8 - (fmt->Aloss << 1))); \
+    }                                                                 \
+    else                                                              \
+    {                                                                 \
+        _sA = 255;                                                    \
+    }
+
+#define GET_PIXELVALS_1(sr, sg, sb, sa, _src, _fmt)    \
+    sr = _fmt->palette->colors[*((Uint8 *) (_src))].r; \
+    sg = _fmt->palette->colors[*((Uint8 *) (_src))].g; \
+    sb = _fmt->palette->colors[*((Uint8 *) (_src))].b; \
+    sa = 255;
+
+/* For 1 byte palette pixels */
+#define SET_PIXELVAL(px, fmt, _dR, _dG, _dB, _dA) \
+    *(px) = (Uint8) SDL_MapRGB(fmt, _dR, _dG, _dB)
+#else /* IS_SDLv2 */
+#define GET_PIXELVALS(_sR, _sG, _sB, _sA, px, fmt, ppa)   \
+    SDL_GetRGBA(px, fmt, &(_sR), &(_sG), &(_sB), &(_sA)); \
+    if (!ppa) {                                           \
+        _sA = 255;                                        \
+    }
+
+#define GET_PIXELVALS_1(sr, sg, sb, sa, _src, _fmt)    \
+    sr = _fmt->palette->colors[*((Uint8 *) (_src))].r; \
+    sg = _fmt->palette->colors[*((Uint8 *) (_src))].g; \
+    sb = _fmt->palette->colors[*((Uint8 *) (_src))].b; \
+    sa = 255;
+
+/* For 1 byte palette pixels */
+#define SET_PIXELVAL(px, fmt, _dR, _dG, _dB, _dA) \
+    *(px) = (Uint8) SDL_MapRGBA(fmt, _dR, _dG, _dB, _dA)
+#endif /* IS_SDLv2 */
+
+
+
+
+
+
+
+
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+#define SET_OFFSETS_24(or, og, ob, fmt)           \
+    {                                             \
+    or = (fmt->Rshift == 0 ? 0 :                  \
+          fmt->Rshift == 8 ? 1 :                  \
+                         2   );                   \
+    og = (fmt->Gshift == 0 ? 0 :                  \
+          fmt->Gshift == 8 ? 1 :                  \
+                         2   );                   \
+    ob = (fmt->Bshift == 0 ? 0 :                  \
+          fmt->Bshift == 8 ? 1 :                  \
+                         2   );                   \
+    }
+
+#define SET_OFFSETS_32(or, og, ob, fmt)           \
+    {                                             \
+    or = (fmt->Rshift == 0  ? 0 :                 \
+          fmt->Rshift == 8  ? 1 :                 \
+          fmt->Rshift == 16 ? 2 :                 \
+                          3   );                  \
+    og = (fmt->Gshift == 0  ? 0 :                 \
+          fmt->Gshift == 8  ? 1 :                 \
+          fmt->Gshift == 16 ? 2 :                 \
+                          3   );                  \
+    ob = (fmt->Bshift == 0  ? 0 :                 \
+          fmt->Bshift == 8  ? 1 :                 \
+          fmt->Bshift == 16 ? 2 :                 \
+                          3   );                  \
+    }
+#else
+#define SET_OFFSETS_24(or, og, ob, fmt)           \
+    {                                             \
+    or = (fmt->Rshift == 0 ? 2 :                  \
+          fmt->Rshift == 8 ? 1 :                  \
+                         0   );                   \
+    og = (fmt->Gshift == 0 ? 2 :                  \
+          fmt->Gshift == 8 ? 1 :                  \
+                         0   );                   \
+    ob = (fmt->Bshift == 0 ? 2 :                  \
+          fmt->Bshift == 8 ? 1 :                  \
+                         0   );                   \
+    }
+
+#define SET_OFFSETS_32(or, og, ob, fmt)           \
+    {                                             \
+    or = (fmt->Rshift == 0  ? 3 :                 \
+          fmt->Rshift == 8  ? 2 :                 \
+          fmt->Rshift == 16 ? 1 :                 \
+                          0   );                  \
+    og = (fmt->Gshift == 0  ? 3 :                 \
+          fmt->Gshift == 8  ? 2 :                 \
+          fmt->Gshift == 16 ? 1 :                 \
+                          0   );                  \
+    ob = (fmt->Bshift == 0  ? 3 :                 \
+          fmt->Bshift == 8  ? 2 :                 \
+          fmt->Bshift == 16 ? 1 :                 \
+                          0   );                  \
+    }
+#endif
+
+
+#define CREATE_PIXEL(buf, r, g, b, a, bp, ft)     \
+    switch (bp)                                   \
+    {                                             \
+    case 2:                                       \
+        *((Uint16 *) (buf)) =                     \
+            ((r >> ft->Rloss) << ft->Rshift) |    \
+            ((g >> ft->Gloss) << ft->Gshift) |    \
+            ((b >> ft->Bloss) << ft->Bshift) |    \
+            ((a >> ft->Aloss) << ft->Ashift);     \
+        break;                                    \
+    case 4:                                       \
+        *((Uint32 *) (buf)) =                     \
+            ((r >> ft->Rloss) << ft->Rshift) |    \
+            ((g >> ft->Gloss) << ft->Gshift) |    \
+            ((b >> ft->Bloss) << ft->Bshift) |    \
+            ((a >> ft->Aloss) << ft->Ashift);     \
+        break;                                    \
+    }
+
+/* Pretty good idea from Tom Duff :-). */
+#define LOOP_UNROLLED4(code, n, width) \
+    n = (width + 3) / 4;               \
+    switch (width & 3)                 \
+    {                                  \
+    case 0: do { code;                 \
+        case 3: code;                  \
+        case 2: code;                  \
+        case 1: code;                  \
+        } while (--n > 0);             \
+    }
+
+/* Used in the srcbpp == dstbpp == 1 blend functions */
+#define REPEAT_3(code) \
+    code;              \
+    code;              \
+    code;
+
+#define REPEAT_4(code) \
+    code;              \
+    code;              \
+    code;              \
+    code;
+
+
+#define BLEND_ADD(tmp, sR, sG, sB, sA, dR, dG, dB, dA)  \
+    tmp = dR + sR; dR = (tmp <= 255 ? tmp : 255);       \
+    tmp = dG + sG; dG = (tmp <= 255 ? tmp : 255);       \
+    tmp = dB + sB; dB = (tmp <= 255 ? tmp : 255);
+
+#define BLEND_SUB(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \
+    tmp = dR - sR; dR = (tmp >= 0 ? tmp : 0);          \
+    tmp = dG - sG; dG = (tmp >= 0 ? tmp : 0);          \
+    tmp = dB - sB; dB = (tmp >= 0 ? tmp : 0);
+
+#define BLEND_MULT(sR, sG, sB, sA, dR, dG, dB, dA) \
+    dR = (dR && sR) ? (dR * sR) >> 8 : 0;          \
+    dG = (dG && sG) ? (dG * sG) >> 8 : 0;          \
+    dB = (dB && sB) ? (dB * sB) >> 8 : 0;
+
+#define BLEND_MIN(sR, sG, sB, sA, dR, dG, dB, dA) \
+    if(sR < dR) { dR = sR; }                      \
+    if(sG < dG) { dG = sG; }                      \
+    if(sB < dB) { dB = sB; }
+
+#define BLEND_MAX(sR, sG, sB, sA, dR, dG, dB, dA) \
+    if(sR > dR) { dR = sR; }                      \
+    if(sG > dG) { dG = sG; }                      \
+    if(sB > dB) { dB = sB; }
+
+
+
+
+
+
+#define BLEND_RGBA_ADD(tmp, sR, sG, sB, sA, dR, dG, dB, dA)  \
+    tmp = dR + sR; dR = (tmp <= 255 ? tmp : 255);       \
+    tmp = dG + sG; dG = (tmp <= 255 ? tmp : 255);       \
+    tmp = dB + sB; dB = (tmp <= 255 ? tmp : 255);       \
+    tmp = dA + sA; dA = (tmp <= 255 ? tmp : 255);
+
+#define BLEND_RGBA_SUB(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \
+    tmp = dR - sR; dR = (tmp >= 0 ? tmp : 0);          \
+    tmp = dG - sG; dG = (tmp >= 0 ? tmp : 0);          \
+    tmp = dB - sB; dB = (tmp >= 0 ? tmp : 0);          \
+    tmp = dA - sA; dA = (tmp >= 0 ? tmp : 0);
+
+#define BLEND_RGBA_MULT(sR, sG, sB, sA, dR, dG, dB, dA) \
+    dR = (dR && sR) ? (dR * sR) >> 8 : 0;          \
+    dG = (dG && sG) ? (dG * sG) >> 8 : 0;          \
+    dB = (dB && sB) ? (dB * sB) >> 8 : 0;          \
+    dA = (dA && sA) ? (dA * sA) >> 8 : 0;
+
+#define BLEND_RGBA_MIN(sR, sG, sB, sA, dR, dG, dB, dA) \
+    if(sR < dR) { dR = sR; }                      \
+    if(sG < dG) { dG = sG; }                      \
+    if(sB < dB) { dB = sB; }                      \
+    if(sA < dA) { dA = sA; }
+
+#define BLEND_RGBA_MAX(sR, sG, sB, sA, dR, dG, dB, dA) \
+    if(sR > dR) { dR = sR; }                      \
+    if(sG > dG) { dG = sG; }                      \
+    if(sB > dB) { dB = sB; }                      \
+    if(sA > dA) { dA = sA; }
+
+
+
+
+
+
+
+
+
+
+
+#if 1
+/* Choose an alpha blend equation. If the sign is preserved on a right shift
+ * then use a specialized, faster, equation. Otherwise a more general form,
+ * where all additions are done before the shift, is needed.
+*/
+#if (-1 >> 1) < 0
+#define ALPHA_BLEND_COMP(sC, dC, sA) ((((sC - dC) * sA + sC) >> 8) + dC)
+#else
+#define ALPHA_BLEND_COMP(sC, dC, sA) (((dC << 8) + (sC - dC) * sA + sC) >> 8)
+#endif
+
+#define ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB, dA) \
+    do {                                            \
+        if (dA)                                     \
+        {                                           \
+            dR = ALPHA_BLEND_COMP(sR, dR, sA);      \
+            dG = ALPHA_BLEND_COMP(sG, dG, sA);      \
+            dB = ALPHA_BLEND_COMP(sB, dB, sA);      \
+            dA = sA + dA - ((sA * dA) / 255);       \
+        }                                           \
+        else                                        \
+        {                                           \
+            dR = sR;                                \
+            dG = sG;                                \
+            dB = sB;                                \
+            dA = sA;                                \
+        }                                           \
+    } while(0)
+
+#define ALPHA_BLEND_PREMULTIPLIED_COMP(sC, dC, sA) (sC + dC - ((dC * sA) >> 8))
+
+#define ALPHA_BLEND_PREMULTIPLIED(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \
+    do {                                            \
+            tmp = ALPHA_BLEND_PREMULTIPLIED_COMP(sR, dR, sA); dR = (tmp > 255 ? 255 : tmp); \
+            tmp = ALPHA_BLEND_PREMULTIPLIED_COMP(sG, dG, sA); dG = (tmp > 255 ? 255 : tmp); \
+            tmp = ALPHA_BLEND_PREMULTIPLIED_COMP(sB, dB, sA); dB = (tmp > 255 ? 255 : tmp); \
+            dA = sA + dA - ((sA * dA) / 255);       \
+    } while(0)
+#elif 0
+
+#define ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB, dA)    \
+    do {                                               \
+        if(sA){                                        \
+            if(dA && sA < 255){                        \
+                int dContrib = dA*(255 - sA)/255;      \
+                dA = sA+dA - ((sA*dA)/255);            \
+                dR = (dR*dContrib + sR*sA)/dA;         \
+                dG = (dG*dContrib + sG*sA)/dA;         \
+                dB = (dB*dContrib + sB*sA)/dA;         \
+            }else{                                     \
+                dR = sR;                               \
+                dG = sG;                               \
+                dB = sB;                               \
+                dA = sA;                               \
+            }                                          \
+        }                                              \
+    } while(0)
+#endif
+
+int
+surface_fill_blend (SDL_Surface *surface, SDL_Rect *rect, Uint32 color,
+                    int blendargs);
+
+void
+surface_respect_clip_rect (SDL_Surface *surface, SDL_Rect *rect);
+
+int
+pygame_AlphaBlit (SDL_Surface * src, SDL_Rect * srcrect,
+                  SDL_Surface * dst, SDL_Rect * dstrect, int the_args);
+
+int
+pygame_Blit (SDL_Surface * src, SDL_Rect * srcrect,
+             SDL_Surface * dst, SDL_Rect * dstrect, int the_args);
+
+#endif /* SURFACE_H */

venv/Scripts/Activate.ps1

@@ -0,0 +1,51 @@
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+    if (Test-Path function:_OLD_VIRTUAL_PROMPT) {
+        copy-item function:_OLD_VIRTUAL_PROMPT function:prompt
+        remove-item function:_OLD_VIRTUAL_PROMPT
+    }
+
+    if (Test-Path env:_OLD_VIRTUAL_PYTHONHOME) {
+        copy-item env:_OLD_VIRTUAL_PYTHONHOME env:PYTHONHOME
+        remove-item env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    if (Test-Path env:_OLD_VIRTUAL_PATH) {
+        copy-item env:_OLD_VIRTUAL_PATH env:PATH
+        remove-item env:_OLD_VIRTUAL_PATH
+    }
+
+    if (Test-Path env:VIRTUAL_ENV) {
+        remove-item env:VIRTUAL_ENV
+    }
+
+    if (!$NonDestructive) {
+        # Self destruct!
+        remove-item function:deactivate
+    }
+}
+
+deactivate -nondestructive
+
+$env:VIRTUAL_ENV="C:\Users\Administrator\Desktop\CoTan\venv"
+
+if (! $env:VIRTUAL_ENV_DISABLE_PROMPT) {
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT {""}
+    copy-item function:prompt function:_OLD_VIRTUAL_PROMPT
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green '(venv) '
+        _OLD_VIRTUAL_PROMPT
+    }
+}
+
+# Clear PYTHONHOME
+if (Test-Path env:PYTHONHOME) {
+    copy-item env:PYTHONHOME env:_OLD_VIRTUAL_PYTHONHOME
+    remove-item env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+copy-item env:PATH env:_OLD_VIRTUAL_PATH
+$env:PATH = "$env:VIRTUAL_ENV\Scripts;$env:PATH"

venv/Scripts/activate

@@ -0,0 +1,76 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+        hash -r
+    fi
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="C:\Users\Administrator\Desktop\CoTan\venv"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/Scripts:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    if [ "x(venv) " != x ] ; then
+	PS1="(venv) ${PS1:-}"
+    else
+    if [ "`basename \"$VIRTUAL_ENV\"`" = "__" ] ; then
+        # special case for Aspen magic directories
+        # see http://www.zetadev.com/software/aspen/
+        PS1="[`basename \`dirname \"$VIRTUAL_ENV\"\``] $PS1"
+    else
+        PS1="(`basename \"$VIRTUAL_ENV\"`)$PS1"
+    fi
+    fi
+    export PS1
+fi
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+    hash -r
+fi

venv/Scripts/activate.bat

@@ -0,0 +1,33 @@
+@echo off
+
+rem This file is UTF-8 encoded, so we need to update the current code page while executing it
+for /f "tokens=2 delims=:." %%a in ('"%SystemRoot%\System32\chcp.com"') do (
+    set _OLD_CODEPAGE=%%a
+)
+if defined _OLD_CODEPAGE (
+    "%SystemRoot%\System32\chcp.com" 65001 > nul
+)
+
+set VIRTUAL_ENV=C:\Users\Administrator\Desktop\CoTan\venv
+
+if not defined PROMPT set PROMPT=$P$G
+
+if defined _OLD_VIRTUAL_PROMPT set PROMPT=%_OLD_VIRTUAL_PROMPT%
+if defined _OLD_VIRTUAL_PYTHONHOME set PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%
+
+set _OLD_VIRTUAL_PROMPT=%PROMPT%
+set PROMPT=(venv) %PROMPT%
+
+if defined PYTHONHOME set _OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%
+set PYTHONHOME=
+
+if defined _OLD_VIRTUAL_PATH set PATH=%_OLD_VIRTUAL_PATH%
+if not defined _OLD_VIRTUAL_PATH set _OLD_VIRTUAL_PATH=%PATH%
+
+set PATH=%VIRTUAL_ENV%\Scripts;%PATH%
+
+:END
+if defined _OLD_CODEPAGE (
+    "%SystemRoot%\System32\chcp.com" %_OLD_CODEPAGE% > nul
+    set _OLD_CODEPAGE=
+)

venv/Scripts/deactivate.bat

@@ -0,0 +1,21 @@
+@echo off
+
+if defined _OLD_VIRTUAL_PROMPT (
+    set "PROMPT=%_OLD_VIRTUAL_PROMPT%"
+)
+set _OLD_VIRTUAL_PROMPT=
+
+if defined _OLD_VIRTUAL_PYTHONHOME (
+    set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%"
+    set _OLD_VIRTUAL_PYTHONHOME=
+)
+
+if defined _OLD_VIRTUAL_PATH (
+    set "PATH=%_OLD_VIRTUAL_PATH%"
+)
+
+set _OLD_VIRTUAL_PATH=
+
+set VIRTUAL_ENV=
+
+:END

venv/Scripts/htmlmin-script.py

@@ -0,0 +1,12 @@
+#!c:\users\administrator\desktop\cotan\venv\scripts\python.exe
+# EASY-INSTALL-ENTRY-SCRIPT: 'htmlmin==0.1.12','console_scripts','htmlmin'
+__requires__ = 'htmlmin==0.1.12'
+import re
+import sys
+from pkg_resources import load_entry_point
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(
+        load_entry_point('htmlmin==0.1.12', 'console_scripts', 'htmlmin')()
+    )

venv/Scripts/kaggle-script.py

@@ -0,0 +1,12 @@
+#!c:\users\administrator\desktop\cotan\venv\scripts\python.exe
+# EASY-INSTALL-ENTRY-SCRIPT: 'kaggle==1.5.6','console_scripts','kaggle'
+__requires__ = 'kaggle==1.5.6'
+import re
+import sys
+from pkg_resources import load_entry_point
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(
+        load_entry_point('kaggle==1.5.6', 'console_scripts', 'kaggle')()
+    )

venv/Scripts/numba

@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+from __future__ import print_function, division, absolute_import
+
+from numba.numba_entry import main
+
+if __name__ == "__main__":
+    main()

venv/Scripts/pandas_profiling-script.py

@@ -0,0 +1,12 @@
+#!c:\users\administrator\desktop\cotan\venv\scripts\python.exe
+# EASY-INSTALL-ENTRY-SCRIPT: 'pandas-profiling==2.5.0','console_scripts','pandas_profiling'
+__requires__ = 'pandas-profiling==2.5.0'
+import re
+import sys
+from pkg_resources import load_entry_point
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(
+        load_entry_point('pandas-profiling==2.5.0', 'console_scripts', 'pandas_profiling')()
+    )

venv/Scripts/pycc

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+from numba.pycc import main
+main()

venv/Scripts/pywin32_postinstall.py

@@ -0,0 +1,637 @@
+# postinstall script for pywin32
+#
+# copies PyWinTypesxx.dll and PythonCOMxx.dll into the system directory,
+# and creates a pth file
+import os
+import sys
+import glob
+import shutil
+import time
+import distutils.sysconfig
+try:
+    import winreg as winreg
+except:
+    import winreg
+
+# Send output somewhere so it can be found if necessary...
+import tempfile
+tee_f = open(os.path.join(tempfile.gettempdir(), 'pywin32_postinstall.log'), "w")
+class Tee:
+    def __init__(self, file):
+        self.f = file
+    def write(self, what):
+        if self.f is not None:
+            try:
+                self.f.write(what.replace("\n", "\r\n"))
+            except IOError:
+                pass
+        tee_f.write(what)
+    def flush(self):
+        if self.f is not None:
+            try:
+                self.f.flush()
+            except IOError:
+                pass
+        tee_f.flush()
+
+# For some unknown reason, when running under bdist_wininst we will start up
+# with sys.stdout as None but stderr is hooked up. This work-around allows
+# bdist_wininst to see the output we write and display it at the end of
+# the install.
+if sys.stdout is None:
+    sys.stdout = sys.stderr
+
+sys.stderr = Tee(sys.stderr)
+sys.stdout = Tee(sys.stdout)
+
+com_modules = [
+    # module_name,                      class_names
+    ("win32com.servers.interp",         "Interpreter"),
+    ("win32com.servers.dictionary",     "DictionaryPolicy"),
+    ("win32com.axscript.client.pyscript","PyScript"),
+]
+
+# Is this a 'silent' install - ie, avoid all dialogs.
+# Different than 'verbose'
+silent = 0
+
+# Verbosity of output messages.
+verbose = 1
+
+ver_string = "%d.%d" % (sys.version_info[0], sys.version_info[1])
+root_key_name = "Software\\Python\\PythonCore\\" + ver_string
+
+try:
+    # When this script is run from inside the bdist_wininst installer,
+    # file_created() and directory_created() are additional builtin
+    # functions which write lines to Python23\pywin32-install.log. This is
+    # a list of actions for the uninstaller, the format is inspired by what
+    # the Wise installer also creates.
+    file_created
+    is_bdist_wininst = True
+except NameError:
+    is_bdist_wininst = False # we know what it is not - but not what it is :)
+    def file_created(file):
+        pass
+    def directory_created(directory):
+        pass
+    def get_root_hkey():
+        try:
+            winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
+                           root_key_name, 0, winreg.KEY_CREATE_SUB_KEY)
+            return winreg.HKEY_LOCAL_MACHINE
+        except OSError as details:
+            # Either not exist, or no permissions to create subkey means
+            # must be HKCU
+            return winreg.HKEY_CURRENT_USER
+
+try:
+    create_shortcut
+except NameError:
+    # Create a function with the same signature as create_shortcut provided
+    # by bdist_wininst
+    def create_shortcut(path, description, filename,
+                        arguments="", workdir="", iconpath="", iconindex=0):
+        import pythoncom
+        from win32com.shell import shell, shellcon
+
+        ilink = pythoncom.CoCreateInstance(shell.CLSID_ShellLink, None,
+                                           pythoncom.CLSCTX_INPROC_SERVER,
+                                           shell.IID_IShellLink)
+        ilink.SetPath(path)
+        ilink.SetDescription(description)
+        if arguments:
+            ilink.SetArguments(arguments)
+        if workdir:
+            ilink.SetWorkingDirectory(workdir)
+        if iconpath or iconindex:
+            ilink.SetIconLocation(iconpath, iconindex)
+        # now save it.
+        ipf = ilink.QueryInterface(pythoncom.IID_IPersistFile)
+        ipf.Save(filename, 0)
+
+    # Support the same list of "path names" as bdist_wininst.
+    def get_special_folder_path(path_name):
+        import pythoncom
+        from win32com.shell import shell, shellcon
+
+        for maybe in """
+            CSIDL_COMMON_STARTMENU CSIDL_STARTMENU CSIDL_COMMON_APPDATA
+            CSIDL_LOCAL_APPDATA CSIDL_APPDATA CSIDL_COMMON_DESKTOPDIRECTORY
+            CSIDL_DESKTOPDIRECTORY CSIDL_COMMON_STARTUP CSIDL_STARTUP
+            CSIDL_COMMON_PROGRAMS CSIDL_PROGRAMS CSIDL_PROGRAM_FILES_COMMON
+            CSIDL_PROGRAM_FILES CSIDL_FONTS""".split():
+            if maybe == path_name:
+                csidl = getattr(shellcon, maybe)
+                return shell.SHGetSpecialFolderPath(0, csidl, False)
+        raise ValueError("%s is an unknown path ID" % (path_name,))
+
+def CopyTo(desc, src, dest):
+    import win32api, win32con
+    while 1:
+        try:
+            win32api.CopyFile(src, dest, 0)
+            return
+        except win32api.error as details:
+            if details.winerror==5: # access denied - user not admin.
+                raise
+            if silent:
+                # Running silent mode - just re-raise the error.
+                raise
+            tb = None
+            full_desc = "Error %s\n\n" \
+                        "If you have any Python applications running, " \
+                        "please close them now\nand select 'Retry'\n\n%s" \
+                        % (desc, details.strerror)
+            rc = win32api.MessageBox(0,
+                                     full_desc,
+                                     "Installation Error",
+                                     win32con.MB_ABORTRETRYIGNORE)
+            if rc == win32con.IDABORT:
+                raise
+            elif rc == win32con.IDIGNORE:
+                return
+            # else retry - around we go again.
+
+# We need to import win32api to determine the Windows system directory,
+# so we can copy our system files there - but importing win32api will
+# load the pywintypes.dll already in the system directory preventing us
+# from updating them!
+# So, we pull the same trick pywintypes.py does, but it loads from
+# our pywintypes_system32 directory.
+def LoadSystemModule(lib_dir, modname):
+    # See if this is a debug build.
+    import imp
+    for suffix_item in imp.get_suffixes():
+        if suffix_item[0]=='_d.pyd':
+            suffix = '_d'
+            break
+    else:
+        suffix = ""
+    filename = "%s%d%d%s.dll" % \
+               (modname, sys.version_info[0], sys.version_info[1], suffix)
+    filename = os.path.join(lib_dir, "pywin32_system32", filename)
+    mod = imp.load_dynamic(modname, filename)
+
+
+def SetPyKeyVal(key_name, value_name, value):
+    root_hkey = get_root_hkey()
+    root_key = winreg.OpenKey(root_hkey, root_key_name)
+    try:
+        my_key = winreg.CreateKey(root_key, key_name)
+        try:
+            winreg.SetValueEx(my_key, value_name, 0, winreg.REG_SZ, value)
+        finally:
+            my_key.Close()
+    finally:
+        root_key.Close()
+    if verbose:
+        print(("-> %s\\%s[%s]=%r" % (root_key_name, key_name, value_name, value)))
+
+def RegisterCOMObjects(register = 1):
+    import win32com.server.register
+    if register:
+        func = win32com.server.register.RegisterClasses
+    else:
+        func = win32com.server.register.UnregisterClasses
+    flags = {}
+    if not verbose:
+        flags['quiet']=1
+    for module, klass_name in com_modules:
+        __import__(module)
+        mod = sys.modules[module]
+        flags["finalize_register"] = getattr(mod, "DllRegisterServer", None)
+        flags["finalize_unregister"] = getattr(mod, "DllUnregisterServer", None)
+        klass = getattr(mod, klass_name)
+        func(klass, **flags)
+
+def RegisterPythonwin(register=True):
+    """ Add (or remove) Pythonwin to context menu for python scripts.
+        ??? Should probably also add Edit command for pys files also.
+        Also need to remove these keys on uninstall, but there's no function
+            like file_created to add registry entries to uninstall log ???
+    """
+    import os
+
+    lib_dir = distutils.sysconfig.get_python_lib(plat_specific=1)
+    classes_root=get_root_hkey()
+    ## Installer executable doesn't seem to pass anything to postinstall script indicating if it's a debug build,
+    pythonwin_exe = os.path.join(lib_dir, "Pythonwin", "Pythonwin.exe")
+    pythonwin_edit_command=pythonwin_exe + ' /edit "%1"'
+
+    keys_vals = [
+        ('Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\Pythonwin.exe', '', pythonwin_exe),
+        ('Software\\Classes\\Python.File\\shell\\Edit with Pythonwin', 'command', pythonwin_edit_command),
+        ('Software\\Classes\\Python.NoConFile\\shell\\Edit with Pythonwin', 'command', pythonwin_edit_command),
+        ]
+
+    try:
+        if register:
+            for key, sub_key, val in keys_vals:
+                ## Since winreg only uses the character Api functions, this can fail if Python
+                ##  is installed to a path containing non-ascii characters
+                hkey = winreg.CreateKey(classes_root, key)
+                if sub_key:
+                    hkey = winreg.CreateKey(hkey, sub_key)
+                winreg.SetValueEx(hkey, None, 0, winreg.REG_SZ, val)
+                hkey.Close()
+        else:
+            for key, sub_key, val in keys_vals:
+                try:
+                    winreg.DeleteKey(classes_root, key)
+                except OSError as why:
+                    winerror = getattr(why, 'winerror', why.errno)
+                    if winerror != 2: # file not found
+                        raise
+    finally:
+        # tell windows about the change
+        from win32com.shell import shell, shellcon
+        shell.SHChangeNotify(shellcon.SHCNE_ASSOCCHANGED, shellcon.SHCNF_IDLIST, None, None)
+
+def get_shortcuts_folder():
+    if get_root_hkey()==winreg.HKEY_LOCAL_MACHINE:
+        try:
+            fldr = get_special_folder_path("CSIDL_COMMON_PROGRAMS")
+        except OSError:
+            # No CSIDL_COMMON_PROGRAMS on this platform
+            fldr = get_special_folder_path("CSIDL_PROGRAMS")
+    else:
+        # non-admin install - always goes in this user's start menu.
+        fldr = get_special_folder_path("CSIDL_PROGRAMS")
+
+    try:
+        install_group = winreg.QueryValue(get_root_hkey(),
+                                           root_key_name + "\\InstallPath\\InstallGroup")
+    except OSError:
+        vi = sys.version_info
+        install_group = "Python %d.%d" % (vi[0], vi[1])
+    return os.path.join(fldr, install_group)
+
+# Get the system directory, which may be the Wow64 directory if we are a 32bit
+# python on a 64bit OS.
+def get_system_dir():
+    import win32api # we assume this exists.
+    try:
+        import pythoncom
+        import win32process
+        from win32com.shell import shell, shellcon
+        try:
+            if win32process.IsWow64Process():
+                return shell.SHGetSpecialFolderPath(0,shellcon.CSIDL_SYSTEMX86)
+            return shell.SHGetSpecialFolderPath(0,shellcon.CSIDL_SYSTEM)
+        except (pythoncom.com_error, win32process.error):
+            return win32api.GetSystemDirectory()
+    except ImportError:
+        return win32api.GetSystemDirectory()
+
+def fixup_dbi():
+    # We used to have a dbi.pyd with our .pyd files, but now have a .py file.
+    # If the user didn't uninstall, they will find the .pyd which will cause
+    # problems - so handle that.
+    import win32api, win32con
+    pyd_name = os.path.join(os.path.dirname(win32api.__file__), "dbi.pyd")
+    pyd_d_name = os.path.join(os.path.dirname(win32api.__file__), "dbi_d.pyd")
+    py_name = os.path.join(os.path.dirname(win32con.__file__), "dbi.py")
+    for this_pyd in (pyd_name, pyd_d_name):
+        this_dest = this_pyd + ".old"
+        if os.path.isfile(this_pyd) and os.path.isfile(py_name):
+            try:
+                if os.path.isfile(this_dest):
+                    print(("Old dbi '%s' already exists - deleting '%s'" % (this_dest, this_pyd)))
+                    os.remove(this_pyd)
+                else:
+                    os.rename(this_pyd, this_dest)
+                    print(("renamed '%s'->'%s.old'" % (this_pyd, this_pyd)))
+                    file_created(this_pyd+".old")
+            except os.error as exc:
+                print(("FAILED to rename '%s': %s" % (this_pyd, exc)))
+
+def install(lib_dir):
+    import traceback
+    # The .pth file is now installed as a regular file.
+    # Create the .pth file in the site-packages dir, and use only relative paths
+    # We used to write a .pth directly to sys.prefix - clobber it.
+    if os.path.isfile(os.path.join(sys.prefix, "pywin32.pth")):
+        os.unlink(os.path.join(sys.prefix, "pywin32.pth"))
+    # The .pth may be new and therefore not loaded in this session.
+    # Setup the paths just in case.
+    for name in "win32 win32\\lib Pythonwin".split():
+        sys.path.append(os.path.join(lib_dir, name))
+    # It is possible people with old versions installed with still have
+    # pywintypes and pythoncom registered.  We no longer need this, and stale
+    # entries hurt us.
+    for name in "pythoncom pywintypes".split():
+        keyname = "Software\\Python\\PythonCore\\" + sys.winver + "\\Modules\\" + name
+        for root in winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER:
+            try:
+                winreg.DeleteKey(root, keyname + "\\Debug")
+            except WindowsError:
+                pass
+            try:
+                winreg.DeleteKey(root, keyname)
+            except WindowsError:
+                pass
+    LoadSystemModule(lib_dir, "pywintypes")
+    LoadSystemModule(lib_dir, "pythoncom")
+    import win32api
+    # and now we can get the system directory:
+    files = glob.glob(os.path.join(lib_dir, "pywin32_system32\\*.*"))
+    if not files:
+        raise RuntimeError("No system files to copy!!")
+    # Try the system32 directory first - if that fails due to "access denied",
+    # it implies a non-admin user, and we use sys.prefix
+    for dest_dir in [get_system_dir(), sys.prefix]:
+        # and copy some files over there
+        worked = 0
+        try:
+            for fname in files:
+                base = os.path.basename(fname)
+                dst = os.path.join(dest_dir, base)
+                CopyTo("installing %s" % base, fname, dst)
+                if verbose:
+                    print(("Copied %s to %s" % (base, dst)))
+                # Register the files with the uninstaller
+                file_created(dst)
+                worked = 1
+                # If this isn't sys.prefix (ie, System32), then nuke
+                # any versions that may exist in sys.prefix - having
+                # duplicates causes major headaches.
+                if dest_dir != sys.prefix:
+                    bad_fname = os.path.join(sys.prefix, base)
+                    if os.path.exists(bad_fname):
+                        # let exceptions go here - delete must succeed
+                        os.unlink(bad_fname)
+            if worked:
+                break
+        except win32api.error as details:
+            if details.winerror==5:
+                # access denied - user not admin - try sys.prefix dir,
+                # but first check that a version doesn't already exist
+                # in that place - otherwise that one will still get used!
+                if os.path.exists(dst):
+                    msg = "The file '%s' exists, but can not be replaced " \
+                          "due to insufficient permissions.  You must " \
+                          "reinstall this software as an Administrator" \
+                          % dst
+                    print(msg)
+                    raise RuntimeError(msg)
+                continue
+            raise
+    else:
+        raise RuntimeError(
+              "You don't have enough permissions to install the system files")
+
+    # Pythonwin 'compiles' config files - record them for uninstall.
+    pywin_dir = os.path.join(lib_dir, "Pythonwin", "pywin")
+    for fname in glob.glob(os.path.join(pywin_dir, "*.cfg")):
+        file_created(fname[:-1] + "c") # .cfg->.cfc
+
+    # Register our demo COM objects.
+    try:
+        try:
+            RegisterCOMObjects()
+        except win32api.error as details:
+            if details.winerror!=5: # ERROR_ACCESS_DENIED
+                raise
+            print("You do not have the permissions to install COM objects.")
+            print("The sample COM objects were not registered.")
+    except:
+        print("FAILED to register the Python COM objects")
+        traceback.print_exc()
+
+    # There may be no main Python key in HKCU if, eg, an admin installed
+    # python itself.
+    winreg.CreateKey(get_root_hkey(), root_key_name)
+
+    # Register the .chm help file.
+    chm_file = os.path.join(lib_dir, "PyWin32.chm")
+    if os.path.isfile(chm_file):
+        # This isn't recursive, so if 'Help' doesn't exist, we croak
+        SetPyKeyVal("Help", None, None)
+        SetPyKeyVal("Help\\Pythonwin Reference", None, chm_file)
+    else:
+        print("NOTE: PyWin32.chm can not be located, so has not " \
+              "been registered")
+
+    # misc other fixups.
+    fixup_dbi()
+
+    # Register Pythonwin in context menu
+    try:
+        RegisterPythonwin()
+    except:
+        print('Failed to register pythonwin as editor')
+        traceback.print_exc()
+    else:
+        if verbose:
+            print('Pythonwin has been registered in context menu')
+
+    # Create the win32com\gen_py directory.
+    make_dir = os.path.join(lib_dir, "win32com", "gen_py")
+    if not os.path.isdir(make_dir):
+        if verbose:
+            print(("Creating directory %s" % (make_dir,)))
+        directory_created(make_dir)
+        os.mkdir(make_dir)
+
+    try:
+        # create shortcuts
+        # CSIDL_COMMON_PROGRAMS only available works on NT/2000/XP, and
+        # will fail there if the user has no admin rights.
+        fldr = get_shortcuts_folder()
+        # If the group doesn't exist, then we don't make shortcuts - its
+        # possible that this isn't a "normal" install.
+        if os.path.isdir(fldr):
+            dst = os.path.join(fldr, "PythonWin.lnk")
+            create_shortcut(os.path.join(lib_dir, "Pythonwin\\Pythonwin.exe"),
+                            "The Pythonwin IDE", dst, "", sys.prefix)
+            file_created(dst)
+            if verbose:
+                print("Shortcut for Pythonwin created")
+            # And the docs.
+            dst = os.path.join(fldr, "Python for Windows Documentation.lnk")
+            doc = "Documentation for the PyWin32 extensions"
+            create_shortcut(chm_file, doc, dst)
+            file_created(dst)
+            if verbose:
+                print("Shortcut to documentation created")
+        else:
+            if verbose:
+                print(("Can't install shortcuts - %r is not a folder" % (fldr,)))
+    except Exception as details:
+        print(details)
+
+    # importing win32com.client ensures the gen_py dir created - not strictly
+    # necessary to do now, but this makes the installation "complete"
+    try:
+        import win32com.client
+    except ImportError:
+        # Don't let this error sound fatal
+        pass
+    print("The pywin32 extensions were successfully installed.")
+
+def uninstall(lib_dir):
+    # First ensure our system modules are loaded from pywin32_system, so
+    # we can remove the ones we copied...
+    LoadSystemModule(lib_dir, "pywintypes")
+    LoadSystemModule(lib_dir, "pythoncom")
+
+    try:
+        RegisterCOMObjects(False)
+    except Exception as why:
+        print(("Failed to unregister COM objects: %s" % (why,)))
+
+    try:
+        RegisterPythonwin(False)
+    except Exception as why:
+        print(("Failed to unregister Pythonwin: %s" % (why,)))
+    else:
+        if verbose:
+            print('Unregistered Pythonwin')
+
+    try:
+        # remove gen_py directory.
+        gen_dir = os.path.join(lib_dir, "win32com", "gen_py")
+        if os.path.isdir(gen_dir):
+            shutil.rmtree(gen_dir)
+            if verbose:
+                print(("Removed directory %s" % (gen_dir,)))
+
+        # Remove pythonwin compiled "config" files.
+        pywin_dir = os.path.join(lib_dir, "Pythonwin", "pywin")
+        for fname in glob.glob(os.path.join(pywin_dir, "*.cfc")):
+            os.remove(fname)
+
+        # The dbi.pyd.old files we may have created.
+        try:
+            os.remove(os.path.join(lib_dir, "win32", "dbi.pyd.old"))
+        except os.error:
+            pass
+        try:
+            os.remove(os.path.join(lib_dir, "win32", "dbi_d.pyd.old"))
+        except os.error:
+            pass
+
+    except Exception as why:
+        print(("Failed to remove misc files: %s" % (why,)))
+
+    try:
+        fldr = get_shortcuts_folder()
+        for link in ("PythonWin.lnk", "Python for Windows Documentation.lnk"):
+            fqlink = os.path.join(fldr, link)
+            if os.path.isfile(fqlink):
+                os.remove(fqlink)
+                if verbose:
+                    print(("Removed %s" % (link,)))
+    except Exception as why:
+        print(("Failed to remove shortcuts: %s" % (why,)))
+    # Now remove the system32 files.
+    files = glob.glob(os.path.join(lib_dir, "pywin32_system32\\*.*"))
+    # Try the system32 directory first - if that fails due to "access denied",
+    # it implies a non-admin user, and we use sys.prefix
+    try:
+        for dest_dir in [get_system_dir(), sys.prefix]:
+            # and copy some files over there
+            worked = 0
+            for fname in files:
+                base = os.path.basename(fname)
+                dst = os.path.join(dest_dir, base)
+                if os.path.isfile(dst):
+                    try:
+                        os.remove(dst)
+                        worked = 1
+                        if verbose:
+                            print(("Removed file %s" % (dst)))
+                    except Exception:
+                        print(("FAILED to remove %s" % (dst,)))
+            if worked:
+                break
+    except Exception as why:
+        print(("FAILED to remove system files: %s" % (why,)))
+
+# NOTE: If this script is run from inside the bdist_wininst created
+# binary installer or uninstaller, the command line args are either
+# '-install' or '-remove'.
+
+# Important: From inside the binary installer this script MUST NOT
+# call sys.exit() or raise SystemExit, otherwise not only this script
+# but also the installer will terminate! (Is there a way to prevent
+# this from the bdist_wininst C code?)
+
+
+def verify_destination(location):
+    if not os.path.isdir(location):
+        raise argparse.ArgumentTypeError("Path \"{}\" does not exist!".format(location))
+    return location
+
+
+if __name__ == '__main__':
+    import argparse
+
+    parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,
+                                     description="""A post-install script for the pywin32 extensions.
+
+    * Typical usage:
+
+    > python pywin32_postinstall.py -install
+
+    If you installed pywin32 via a .exe installer, this should be run
+    automatically after installation, but if it fails you can run it again.
+
+    If you installed pywin32 via PIP, you almost certainly need to run this to
+    setup the environment correctly.
+
+    Execute with script with a '-install' parameter, to ensure the environment
+    is setup correctly.
+    """)
+    parser.add_argument("-install",
+                        default=False,
+                        action='store_true',
+                        help="Configure the Python environment correctly for pywin32.")
+    parser.add_argument("-remove",
+                        default=False,
+                        action='store_true',
+                        help="Try and remove everything that was installed or copied.")
+    parser.add_argument("-wait",
+                        type=int,
+                        help="Wait for the specified process to terminate before starting.")
+    parser.add_argument("-silent",
+                        default=False,
+                        action='store_true',
+                        help="Don't display the \"Abort/Retry/Ignore\" dialog for files in use.")
+    parser.add_argument("-quiet",
+                        default=False,
+                        action='store_true',
+                        help="Don't display progress messages.")
+    parser.add_argument("-destination",
+                        default=distutils.sysconfig.get_python_lib(plat_specific=1),
+                        type=verify_destination,
+                        help="Location of the PyWin32 installation")
+
+    args = parser.parse_args()
+
+    if not args.quiet:
+        print(("Parsed arguments are: {}".format(args)))
+
+    if not args.install ^ args.remove:
+        parser.error("You need to either choose to -install or -remove!")
+
+    if args.wait is not None:
+        try:
+            os.waitpid(args.wait, 0)
+        except AttributeError:
+            # Python 2.2 - no waitpid - just sleep.
+            time.sleep(3)
+        except os.error:
+            # child already dead
+            pass
+
+    silent = args.silent
+    verbose = not args.quiet
+
+    if args.install:
+        install(args.destination)
+
+    if args.remove:
+        if not is_bdist_wininst:
+            uninstall(args.destination)

venv/Scripts/pywin32_testall.py

@@ -0,0 +1,71 @@
+"""A test runner for pywin32"""
+import sys
+import os
+import site
+import subprocess
+import win32api
+
+# locate the dirs based on where this script is - it may be either in the
+# source tree, or in an installed Python 'Scripts' tree.
+this_dir = os.path.dirname(__file__)
+site_packages = [site.getusersitepackages(), ] + site.getsitepackages()
+
+# Run a test using subprocess and wait for the result.
+# If we get an returncode != 0, we know that there was an error.
+def run_test(script, cmdline_rest=""):
+    dirname, scriptname = os.path.split(script)
+    # some tests prefer to be run from their directory.
+    cmd = [sys.executable, "-u", scriptname] + cmdline_rest.split()
+    print(script)
+    popen = subprocess.Popen(cmd, shell=True, cwd=dirname,
+                             stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    data = popen.communicate()[0]
+    sys.stdout.buffer.write(data)
+    if popen.returncode:
+        print("****** %s failed: %s" % (script, popen.returncode))
+        sys.exit(popen.returncode)
+
+
+def find_and_run(possible_locations, script, cmdline_rest=""):
+    for maybe in possible_locations:
+        if os.path.isfile(os.path.join(maybe, script)):
+            run_test(os.path.abspath(os.path.join(maybe, script)), cmdline_rest)
+            break
+    else:
+        raise RuntimeError("Failed to locate the test script '%s' in one of %s"
+                           % (script, possible_locations))
+
+if __name__ == '__main__':
+    import argparse
+
+    code_directories = [this_dir] + site_packages
+
+    parser = argparse.ArgumentParser(description="A script to trigger tests in all subprojects of PyWin32.")
+    parser.add_argument("-no-user-interaction",
+                        default=False,
+                        action='store_true',
+                        help="Run all tests without user interaction")
+
+    args = parser.parse_args()
+
+    # win32
+    maybes = [os.path.join(directory, "win32", "test") for directory in code_directories]
+    command = ('testall.py', )
+    if args.no_user_interaction:
+        command += ("-no-user-interaction", )
+    find_and_run(maybes, *command)
+
+    # win32com
+    maybes = [os.path.join(directory, "win32com", "test") for directory in [os.path.join(this_dir, "com"), ] + site_packages]
+    find_and_run(maybes, 'testall.py', "2")
+
+    # adodbapi
+    maybes = [os.path.join(directory, "adodbapi", "test") for directory in code_directories]
+    find_and_run(maybes, 'adodbapitest.py')
+    # This script has a hard-coded sql server name in it, (and markh typically
+    # doesn't have a different server to test on) so don't bother trying to
+    # run it...
+    # find_and_run(maybes, 'test_adodbapi_dbapi20.py')
+
+    if sys.version_info > (3,):
+        print("** The tests have some issues on py3k - not all failures are a problem...")

venv/Scripts/slugify-script.py

@@ -0,0 +1,12 @@
+#!c:\users\administrator\desktop\cotan\venv\scripts\python.exe
+# EASY-INSTALL-ENTRY-SCRIPT: 'python-slugify==4.0.0','console_scripts','slugify'
+__requires__ = 'python-slugify==4.0.0'
+import re
+import sys
+from pkg_resources import load_entry_point
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(
+        load_entry_point('python-slugify==4.0.0', 'console_scripts', 'slugify')()
+    )

venv/etc/jupyter/nbconfig/notebook.d/widgetsnbextension.json

@@ -0,0 +1,5 @@
+{
+  "load_extensions": {
+    "jupyter-js-widgets/extension": true
+  }
+}

venv/pyvenv.cfg

@@ -0,0 +1,3 @@
+home = C:\Users\Administrator\AppData\Local\Programs\Python\Python37
+include-system-site-packages = false
+version = 3.7.5

venv/share/doc/networkx-2.4/LICENSE.txt

@@ -0,0 +1,40 @@
+License
+=======
+
+NetworkX is distributed with the 3-clause BSD license.
+
+::
+
+   Copyright (C) 2004-2019, NetworkX Developers
+   Aric Hagberg <hagberg@lanl.gov>
+   Dan Schult <dschult@colgate.edu>
+   Pieter Swart <swart@lanl.gov>
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+     * Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+     * Redistributions in binary form must reproduce the above
+       copyright notice, this list of conditions and the following
+       disclaimer in the documentation and/or other materials provided
+       with the distribution.
+
+     * Neither the name of the NetworkX Developers nor the names of its
+       contributors may be used to endorse or promote products derived
+       from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

venv/share/doc/networkx-2.4/examples/3d_drawing/README.txt

@@ -0,0 +1,2 @@
+3D Drawing
+----------

venv/share/doc/networkx-2.4/examples/3d_drawing/mayavi2_spring.py

@@ -0,0 +1,46 @@
+"""
+=======
+Mayavi2
+=======
+
+This is
+"""
+
+# needs mayavi2
+# run with ipython -wthread
+import networkx as nx
+import numpy as np
+from mayavi import mlab
+mlab.options.offscreen = True
+
+# some graphs to try
+# H=nx.krackhardt_kite_graph()
+# H=nx.Graph();H.add_edge('a','b');H.add_edge('a','c');H.add_edge('a','d')
+# H=nx.grid_2d_graph(4,5)
+H = nx.cycle_graph(20)
+
+# reorder nodes from 0,len(G)-1
+G = nx.convert_node_labels_to_integers(H)
+# 3d spring layout
+pos = nx.spring_layout(G, dim=3)
+# numpy array of x,y,z positions in sorted node order
+xyz = np.array([pos[v] for v in sorted(G)])
+# scalar colors
+scalars = np.array(list(G.nodes())) + 5
+
+mlab.figure(1, bgcolor=(0, 0, 0))
+mlab.clf()
+
+pts = mlab.points3d(xyz[:, 0], xyz[:, 1], xyz[:, 2],
+                    scalars,
+                    scale_factor=0.1,
+                    scale_mode='none',
+                    colormap='Blues',
+                    resolution=20)
+
+pts.mlab_source.dataset.lines = np.array(list(G.edges()))
+tube = mlab.pipeline.tube(pts, tube_radius=0.01)
+mlab.pipeline.surface(tube, color=(0.8, 0.8, 0.8))
+
+mlab.savefig('mayavi2_spring.png')
+# mlab.show() # interactive window

venv/share/doc/networkx-2.4/examples/README.txt

@@ -0,0 +1,8 @@
+.. _examples_gallery:
+
+Examples
+========
+
+General-purpose and introductory examples for NetworkX.
+The `tutorial <../tutorial.html>`_ introduces conventions and basic graph
+manipulations.

venv/share/doc/networkx-2.4/examples/advanced/README.txt

@@ -0,0 +1,2 @@
+Advanced
+--------

venv/share/doc/networkx-2.4/examples/advanced/plot_eigenvalues.py

@@ -0,0 +1,22 @@
+"""
+===========
+Eigenvalues
+===========
+
+Create an G{n,m} random graph and compute the eigenvalues.
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy.linalg
+
+n = 1000  # 1000 nodes
+m = 5000  # 5000 edges
+G = nx.gnm_random_graph(n, m)
+
+L = nx.normalized_laplacian_matrix(G)
+e = numpy.linalg.eigvals(L.A)
+print("Largest eigenvalue:", max(e))
+print("Smallest eigenvalue:", min(e))
+plt.hist(e, bins=100)  # histogram with 100 bins
+plt.xlim(0, 2)  # eigenvalues between 0 and 2
+plt.show()

venv/share/doc/networkx-2.4/examples/advanced/plot_heavy_metal_umlaut.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+==================
+Heavy Metal Umlaut
+==================
+
+Example using unicode strings as graph labels.
+
+Also shows creative use of the Heavy Metal Umlaut:
+https://en.wikipedia.org/wiki/Heavy_metal_umlaut
+"""
+# Author: Aric Hagberg (hagberg@lanl.gov)
+
+#    Copyright (C) 2006-2019 by
+#    Aric Hagberg <hagberg@lanl.gov>
+#    Dan Schult <dschult@colgate.edu>
+#    Pieter Swart <swart@lanl.gov>
+#    All rights reserved.
+#    BSD license.
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+try:
+    hd = 'H' + unichr(252) + 'sker D' + unichr(252)
+    mh = 'Mot' + unichr(246) + 'rhead'
+    mc = 'M' + unichr(246) + 'tley Cr' + unichr(252) + 'e'
+    st = 'Sp' + unichr(305) + 'n' + unichr(776) + 'al Tap'
+    q = 'Queensr' + unichr(255) + 'che'
+    boc = 'Blue ' + unichr(214) + 'yster Cult'
+    dt = 'Deatht' + unichr(246) + 'ngue'
+except NameError:
+    hd = 'H' + chr(252) + 'sker D' + chr(252)
+    mh = 'Mot' + chr(246) + 'rhead'
+    mc = 'M' + chr(246) + 'tley Cr' + chr(252) + 'e'
+    st = 'Sp' + chr(305) + 'n' + chr(776) + 'al Tap'
+    q = 'Queensr' + chr(255) + 'che'
+    boc = 'Blue ' + chr(214) + 'yster Cult'
+    dt = 'Deatht' + chr(246) + 'ngue'
+
+G = nx.Graph()
+G.add_edge(hd, mh)
+G.add_edge(mc, st)
+G.add_edge(boc, mc)
+G.add_edge(boc, dt)
+G.add_edge(st, dt)
+G.add_edge(q, st)
+G.add_edge(dt, mh)
+G.add_edge(st, mh)
+
+# write in UTF-8 encoding
+fh = open('edgelist.utf-8', 'wb')
+fh.write('# -*- coding: utf-8 -*-\n'.encode('utf-8'))  # encoding hint for emacs
+nx.write_multiline_adjlist(G, fh, delimiter='\t', encoding='utf-8')
+
+# read and store in UTF-8
+fh = open('edgelist.utf-8', 'rb')
+H = nx.read_multiline_adjlist(fh, delimiter='\t', encoding='utf-8')
+
+for n in G.nodes():
+    if n not in H:
+        print(False)
+
+print(list(G.nodes()))
+
+pos = nx.spring_layout(G)
+nx.draw(G, pos, font_size=16, with_labels=False)
+for p in pos:  # raise text positions
+    pos[p][1] += 0.07
+nx.draw_networkx_labels(G, pos)
+plt.show()

venv/share/doc/networkx-2.4/examples/advanced/plot_iterated_dynamical_systems.py

@@ -0,0 +1,205 @@
+"""
+==========================
+Iterated Dynamical Systems
+==========================
+
+Digraphs from Integer-valued Iterated Functions
+
+Sums of cubes on 3N
+-------------------
+
+The number 153 has a curious property.
+
+Let 3N={3,6,9,12,...} be the set of positive multiples of 3.  Define an
+iterative process f:3N->3N as follows: for a given n, take each digit
+of n (in base 10), cube it and then sum the cubes to obtain f(n).
+
+When this process is repeated, the resulting series n, f(n), f(f(n)),...
+terminate in 153 after a finite number of iterations (the process ends
+because 153 = 1**3 + 5**3 + 3**3).
+
+In the language of discrete dynamical systems, 153 is the global
+attractor for the iterated map f restricted to the set 3N.
+
+For example: take the number 108
+
+f(108) = 1**3 + 0**3 + 8**3 = 513
+
+and
+
+f(513) = 5**3 + 1**3 + 3**3 = 153
+
+So, starting at 108 we reach 153 in two iterations,
+represented as:
+
+108->513->153
+
+Computing all orbits of 3N up to 10**5 reveals that the attractor
+153 is reached in a maximum of 14 iterations. In this code we
+show that 13 cycles is the maximum required for all integers (in 3N)
+less than 10,000.
+
+The smallest number that requires 13 iterations to reach 153, is 177, i.e.,
+
+177->687->1071->345->216->225->141->66->432->99->1458->702->351->153
+
+The resulting large digraphs are useful for testing network software.
+
+The general problem
+-------------------
+
+Given numbers n, a power p and base b, define F(n; p, b) as the sum of
+the digits of n (in base b) raised to the power p. The above example
+corresponds to f(n)=F(n; 3,10), and below F(n; p, b) is implemented as
+the function powersum(n,p,b). The iterative dynamical system defined by
+the mapping n:->f(n) above (over 3N) converges to a single fixed point;
+153. Applying the map to all positive integers N, leads to a discrete
+dynamical process with 5 fixed points: 1, 153, 370, 371, 407. Modulo 3
+those numbers are 1, 0, 1, 2, 2. The function f above has the added
+property that it maps a multiple of 3 to another multiple of 3; i.e. it
+is invariant on the subset 3N.
+
+
+The squaring of digits (in base 10) result in cycles and the
+single fixed point 1. I.e., from a certain point on, the process
+starts repeating itself.
+
+keywords: "Recurring Digital Invariant", "Narcissistic Number",
+"Happy Number"
+
+The 3n+1 problem
+----------------
+
+There is a rich history of mathematical recreations
+associated with discrete dynamical systems.  The most famous
+is the Collatz 3n+1 problem. See the function
+collatz_problem_digraph below. The Collatz conjecture
+--- that every orbit returrns to the fixed point 1 in finite time
+--- is still unproven. Even the great Paul Erdos said "Mathematics
+is not yet ready for such problems", and offered $500
+for its solution.
+
+keywords: "3n+1", "3x+1", "Collatz problem", "Thwaite's conjecture"
+"""
+
+import networkx as nx
+
+nmax = 10000
+p = 3
+
+
+def digitsrep(n, b=10):
+    """Return list of digits comprising n represented in base b.
+    n must be a nonnegative integer"""
+
+    if n <= 0:
+        return [0]
+
+    dlist = []
+    while (n > 0):
+        # Prepend next least-significant digit
+        dlist = [n % b] + dlist
+        # Floor-division
+        n = n // b
+    return dlist
+
+
+def powersum(n, p, b=10):
+    """Return sum of digits of n (in base b) raised to the power p."""
+    dlist = digitsrep(n, b)
+    sum = 0
+    for k in dlist:
+        sum += k**p
+    return sum
+
+
+def attractor153_graph(n, p, multiple=3, b=10):
+    """Return digraph of iterations of powersum(n,3,10)."""
+    G = nx.DiGraph()
+    for k in range(1, n + 1):
+        if k % multiple == 0 and k not in G:
+            k1 = k
+            knext = powersum(k1, p, b)
+            while k1 != knext:
+                G.add_edge(k1, knext)
+                k1 = knext
+                knext = powersum(k1, p, b)
+    return G
+
+
+def squaring_cycle_graph_old(n, b=10):
+    """Return digraph of iterations of powersum(n,2,10)."""
+    G = nx.DiGraph()
+    for k in range(1, n + 1):
+        k1 = k
+        G.add_node(k1)  # case k1==knext, at least add node
+        knext = powersum(k1, 2, b)
+        G.add_edge(k1, knext)
+        while k1 != knext:  # stop if fixed point
+            k1 = knext
+            knext = powersum(k1, 2, b)
+            G.add_edge(k1, knext)
+            if G.out_degree(knext) >= 1:
+                # knext has already been iterated in and out
+                break
+    return G
+
+
+def sum_of_digits_graph(nmax, b=10):
+    def f(n): return powersum(n, 1, b)
+    return discrete_dynamics_digraph(nmax, f)
+
+
+def squaring_cycle_digraph(nmax, b=10):
+    def f(n): return powersum(n, 2, b)
+    return discrete_dynamics_digraph(nmax, f)
+
+
+def cubing_153_digraph(nmax):
+    def f(n): return powersum(n, 3, 10)
+    return discrete_dynamics_digraph(nmax, f)
+
+
+def discrete_dynamics_digraph(nmax, f, itermax=50000):
+    G = nx.DiGraph()
+    for k in range(1, nmax + 1):
+        kold = k
+        G.add_node(kold)
+        knew = f(kold)
+        G.add_edge(kold, knew)
+        while kold != knew and kold << itermax:
+            # iterate until fixed point reached or itermax is exceeded
+            kold = knew
+            knew = f(kold)
+            G.add_edge(kold, knew)
+            if G.out_degree(knew) >= 1:
+                # knew has already been iterated in and out
+                break
+    return G
+
+
+def collatz_problem_digraph(nmax):
+    def f(n):
+        if n % 2 == 0:
+            return n // 2
+        else:
+            return 3 * n + 1
+    return discrete_dynamics_digraph(nmax, f)
+
+
+def fixed_points(G):
+    """Return a list of fixed points for the discrete dynamical
+    system represented by the digraph G.
+    """
+    return [n for n in G if G.out_degree(n) == 0]
+
+
+if __name__ == "__main__":
+    nmax = 10000
+    print("Building cubing_153_digraph(%d)" % nmax)
+    G = cubing_153_digraph(nmax)
+    print("Resulting digraph has", len(G), "nodes and",
+          G.size(), " edges")
+    print("Shortest path from 177 to 153 is:")
+    print(nx.shortest_path(G, 177, 153))
+    print("fixed points are %s" % fixed_points(G))

venv/share/doc/networkx-2.4/examples/advanced/plot_parallel_betweenness.py

@@ -0,0 +1,88 @@
+"""
+====================
+Parallel Betweenness
+====================
+
+Example of parallel implementation of betweenness centrality using the
+multiprocessing module from Python Standard Library.
+
+The function betweenness centrality accepts a bunch of nodes and computes
+the contribution of those nodes to the betweenness centrality of the whole
+network. Here we divide the network in chunks of nodes and we compute their
+contribution to the betweenness centrality of the whole network.
+
+This doesn't work in python2.7.13. It does work in 3.6, 3.5, 3.4, and 3.3.
+
+It may be related to this:
+https://stackoverflow.com/questions/1816958/cant-pickle-type-instancemethod-when-using-multiprocessing-pool-map
+"""
+
+from multiprocessing import Pool
+import time
+import itertools
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+
+def chunks(l, n):
+    """Divide a list of nodes `l` in `n` chunks"""
+    l_c = iter(l)
+    while 1:
+        x = tuple(itertools.islice(l_c, n))
+        if not x:
+            return
+        yield x
+
+
+def _betmap(G_normalized_weight_sources_tuple):
+    """Pool for multiprocess only accepts functions with one argument.
+    This function uses a tuple as its only argument. We use a named tuple for
+    python 3 compatibility, and then unpack it when we send it to
+    `betweenness_centrality_source`
+    """
+    return nx.betweenness_centrality_source(*G_normalized_weight_sources_tuple)
+
+
+def betweenness_centrality_parallel(G, processes=None):
+    """Parallel betweenness centrality  function"""
+    p = Pool(processes=processes)
+    node_divisor = len(p._pool) * 4
+    node_chunks = list(chunks(G.nodes(), int(G.order() / node_divisor)))
+    num_chunks = len(node_chunks)
+    bt_sc = p.map(_betmap,
+                  zip([G] * num_chunks,
+                      [True] * num_chunks,
+                      [None] * num_chunks,
+                      node_chunks))
+
+    # Reduce the partial solutions
+    bt_c = bt_sc[0]
+    for bt in bt_sc[1:]:
+        for n in bt:
+            bt_c[n] += bt[n]
+    return bt_c
+
+
+if __name__ == "__main__":
+    G_ba = nx.barabasi_albert_graph(1000, 3)
+    G_er = nx.gnp_random_graph(1000, 0.01)
+    G_ws = nx.connected_watts_strogatz_graph(1000, 4, 0.1)
+    for G in [G_ba, G_er, G_ws]:
+        print("")
+        print("Computing betweenness centrality for:")
+        print(nx.info(G))
+        print("\tParallel version")
+        start = time.time()
+        bt = betweenness_centrality_parallel(G)
+        print("\t\tTime: %.4F" % (time.time() - start))
+        print("\t\tBetweenness centrality for node 0: %.5f" % (bt[0]))
+        print("\tNon-Parallel version")
+        start = time.time()
+        bt = nx.betweenness_centrality(G)
+        print("\t\tTime: %.4F seconds" % (time.time() - start))
+        print("\t\tBetweenness centrality for node 0: %.5f" % (bt[0]))
+    print("")
+
+    nx.draw(G_ba)
+    plt.show()

venv/share/doc/networkx-2.4/examples/algorithms/README.txt

@@ -0,0 +1,2 @@
+Algorithms
+----------

venv/share/doc/networkx-2.4/examples/algorithms/hartford_drug.edgelist

@@ -0,0 +1,338 @@
+# source target
+1 2
+1 10
+2 1
+2 10
+3 7
+4 7
+4 209
+5 132
+6 150
+7 3
+7 4
+7 9
+8 106
+8 115
+9 1
+9 2
+9 7
+10 1
+10 2
+11 133
+11 218
+12 88
+13 214
+14 24
+14 52
+16 10
+16 19
+17 64
+17 78
+18 55
+18 103
+18 163
+19 18
+20 64
+20 180
+21 16
+21 22
+22 21
+22 64
+22 106
+23 20
+23 22
+23 64
+24 14
+24 31
+24 122
+27 115
+28 29
+29 28
+30 19
+31 24
+31 32
+31 122
+31 147
+31 233
+32 31
+32 86
+34 35
+34 37
+35 34
+35 43
+36 132
+36 187
+37 38
+37 90
+37 282
+38 42
+38 43
+38 210
+40 20
+42 15
+42 38
+43 34
+43 35
+43 38
+45 107
+46 61
+46 72
+48 23
+49 30
+49 64
+49 108
+49 115
+49 243
+50 30
+50 47
+50 55
+50 125
+50 163
+52 218
+52 224
+54 111
+54 210
+55 65
+55 67
+55 105
+55 108
+55 222
+56 18
+56 64
+57 65
+57 125
+58 20
+58 30
+58 50
+58 103
+58 180
+59 164
+63 125
+64 8
+64 50
+64 70
+64 256
+66 20
+66 84
+66 106
+66 125
+67 22
+67 50
+67 113
+68 50
+70 50
+70 64
+71 72
+74 29
+74 75
+74 215
+75 74
+75 215
+76 58
+76 104
+77 103
+78 64
+78 68
+80 207
+80 210
+82 8
+82 77
+82 83
+82 97
+82 163
+83 82
+83 226
+83 243
+84 29
+84 154
+87 101
+87 189
+89 90
+90 89
+90 94
+91 86
+92 19
+92 30
+92 106
+94 72
+94 89
+94 90
+95 30
+96 75
+96 256
+97 80
+97 128
+98 86
+100 86
+101 87
+103 77
+103 104
+104 58
+104 77
+104 103
+106 22
+107 38
+107 114
+107 122
+108 49
+108 55
+111 121
+111 128
+111 210
+113 253
+114 107
+116 30
+116 140
+118 129
+118 138
+120 88
+121 128
+122 31
+123 32
+124 244
+125 132
+126 163
+126 180
+128 38
+128 111
+129 118
+132 29
+132 30
+133 30
+134 135
+134 150
+135 134
+137 144
+138 118
+138 129
+139 142
+141 157
+141 163
+142 139
+143 2
+144 137
+145 151
+146 137
+146 165
+146 169
+146 171
+147 31
+147 128
+148 146
+148 169
+148 171
+148 282
+149 128
+149 148
+149 172
+150 86
+151 145
+152 4
+153 134
+154 155
+156 161
+157 141
+161 156
+165 144
+165 148
+167 149
+169 15
+169 148
+169 171
+170 115
+170 173
+170 183
+170 202
+171 72
+171 148
+171 169
+173 170
+175 100
+176 10
+178 181
+181 178
+182 38
+182 171
+183 96
+185 50
+186 127
+187 50
+187 65
+188 30
+188 50
+189 87
+189 89
+190 35
+190 38
+190 122
+190 182
+191 54
+191 118
+191 129
+191 172
+192 149
+192 167
+195 75
+197 50
+197 188
+198 218
+198 221
+198 222
+200 65
+200 220
+201 113
+202 156
+203 232
+204 194
+207 38
+207 122
+207 124
+208 30
+208 50
+210 38
+210 207
+211 37
+213 35
+213 38
+214 13
+214 14
+214 171
+214 213
+215 75
+217 39
+218 68
+218 222
+221 198
+222 198
+222 218
+223 39
+225 3
+226 22
+229 65
+230 68
+231 43
+232 95
+232 203
+233 99
+234 68
+234 230
+237 244
+238 145
+242 3
+242 113
+244 237
+249 96
+250 156
+252 65
+254 65
+258 113
+268 4
+270 183
+272 6
+275 96
+280 183
+280 206
+282 37
+285 75
+290 285
+293 290

venv/share/doc/networkx-2.4/examples/algorithms/plot_beam_search.py

@@ -0,0 +1,101 @@
+# beam_search.py - progressive widening beam search
+#
+# Copyright 2016-2019 NetworkX developers.
+"""
+===========
+Beam Search
+===========
+
+Beam search with dynamic beam width.
+
+The progressive widening beam search repeatedly executes a beam search
+with increasing beam width until the target node is found.
+"""
+import math
+
+import networkx as nx
+
+
+def progressive_widening_search(G, source, value, condition, initial_width=1):
+    """Progressive widening beam search to find a node.
+
+    The progressive widening beam search involves a repeated beam
+    search, starting with a small beam width then extending to
+    progressively larger beam widths if the target node is not
+    found. This implementation simply returns the first node found that
+    matches the termination condition.
+
+    `G` is a NetworkX graph.
+
+    `source` is a node in the graph. The search for the node of interest
+    begins here and extends only to those nodes in the (weakly)
+    connected component of this node.
+
+    `value` is a function that returns a real number indicating how good
+    a potential neighbor node is when deciding which neighbor nodes to
+    enqueue in the breadth-first search. Only the best nodes within the
+    current beam width will be enqueued at each step.
+
+    `condition` is the termination condition for the search. This is a
+    function that takes a node as input and return a Boolean indicating
+    whether the node is the target. If no node matches the termination
+    condition, this function raises :exc:`NodeNotFound`.
+
+    `initial_width` is the starting beam width for the beam search (the
+    default is one). If no node matching the `condition` is found with
+    this beam width, the beam search is restarted from the `source` node
+    with a beam width that is twice as large (so the beam width
+    increases exponentially). The search terminates after the beam width
+    exceeds the number of nodes in the graph.
+
+    """
+    # Check for the special case in which the source node satisfies the
+    # termination condition.
+    if condition(source):
+        return source
+    # The largest possible value of `i` in this range yields a width at
+    # least the number of nodes in the graph, so the final invocation of
+    # `bfs_beam_edges` is equivalent to a plain old breadth-first
+    # search. Therefore, all nodes will eventually be visited.
+    #
+    # TODO In Python 3.3+, this should be `math.log2(len(G))`.
+    log_m = math.ceil(math.log(len(G), 2))
+    for i in range(log_m):
+        width = initial_width * pow(2, i)
+        # Since we are always starting from the same source node, this
+        # search may visit the same nodes many times (depending on the
+        # implementation of the `value` function).
+        for u, v in nx.bfs_beam_edges(G, source, value, width):
+            if condition(v):
+                return v
+    # At this point, since all nodes have been visited, we know that
+    # none of the nodes satisfied the termination condition.
+    raise nx.NodeNotFound('no node satisfied the termination condition')
+
+
+def main():
+    """Search for a node with high centrality.
+
+    In this example, we generate a random graph, compute the centrality
+    of each node, then perform the progressive widening search in order
+    to find a node of high centrality.
+
+    """
+    G = nx.gnp_random_graph(100, 0.5)
+    centrality = nx.eigenvector_centrality(G)
+    avg_centrality = sum(centrality.values()) / len(G)
+
+    def has_high_centrality(v):
+        return centrality[v] >= avg_centrality
+
+    source = 0
+    value = centrality.get
+    condition = has_high_centrality
+
+    found_node = progressive_widening_search(G, source, value, condition)
+    c = centrality[found_node]
+    print('found node {0} with centrality {1}'.format(found_node, c))
+
+
+if __name__ == '__main__':
+    main()

venv/share/doc/networkx-2.4/examples/algorithms/plot_blockmodel.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+==========
+Blockmodel
+==========
+
+Example of creating a block model using the quotient_graph function in NX.  Data
+used is the Hartford, CT drug users network::
+
+    @article{weeks2002social,
+      title={Social networks of drug users in high-risk sites: Finding the connections},
+      url = {https://doi.org/10.1023/A:1015457400897},
+      doi = {10.1023/A:1015457400897},
+      author={Weeks, Margaret R and Clair, Scott and Borgatti, Stephen P and Radda, Kim and Schensul, Jean J},
+      journal={{AIDS and Behavior}},
+      volume={6},
+      number={2},
+      pages={193--206},
+      year={2002},
+      publisher={Springer}
+    }
+
+"""
+# Authors:  Drew Conway <drew.conway@nyu.edu>, Aric Hagberg <hagberg@lanl.gov>
+
+from collections import defaultdict
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy
+from scipy.cluster import hierarchy
+from scipy.spatial import distance
+
+
+def create_hc(G):
+    """Creates hierarchical cluster of graph G from distance matrix"""
+    path_length = nx.all_pairs_shortest_path_length(G)
+    distances = numpy.zeros((len(G), len(G)))
+    for u, p in path_length:
+        for v, d in p.items():
+            distances[u][v] = d
+    # Create hierarchical cluster
+    Y = distance.squareform(distances)
+    Z = hierarchy.complete(Y)  # Creates HC using farthest point linkage
+    # This partition selection is arbitrary, for illustrive purposes
+    membership = list(hierarchy.fcluster(Z, t=1.15))
+    # Create collection of lists for blockmodel
+    partition = defaultdict(list)
+    for n, p in zip(list(range(len(G))), membership):
+        partition[p].append(n)
+    return list(partition.values())
+
+
+if __name__ == '__main__':
+    G = nx.read_edgelist("hartford_drug.edgelist")
+
+    # Extract largest connected component into graph H
+    H = G.subgraph(next(nx.connected_components(G)))
+    # Makes life easier to have consecutively labeled integer nodes
+    H = nx.convert_node_labels_to_integers(H)
+    # Create parititions with hierarchical clustering
+    partitions = create_hc(H)
+    # Build blockmodel graph
+    BM = nx.quotient_graph(H, partitions, relabel=True)
+
+    # Draw original graph
+    pos = nx.spring_layout(H, iterations=100)
+    plt.subplot(211)
+    nx.draw(H, pos, with_labels=False, node_size=10)
+
+    # Draw block model with weighted edges and nodes sized by number of internal nodes
+    node_size = [BM.nodes[x]['nnodes'] * 10 for x in BM.nodes()]
+    edge_width = [(2 * d['weight']) for (u, v, d) in BM.edges(data=True)]
+    # Set positions to mean of positions of internal nodes from original graph
+    posBM = {}
+    for n in BM:
+        xy = numpy.array([pos[u] for u in BM.nodes[n]['graph']])
+        posBM[n] = xy.mean(axis=0)
+    plt.subplot(212)
+    nx.draw(BM, posBM, node_size=node_size, width=edge_width, with_labels=False)
+    plt.axis('off')
+    plt.show()

venv/share/doc/networkx-2.4/examples/algorithms/plot_davis_club.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+"""
+==========
+Davis Club
+==========
+
+Davis Southern Club Women
+
+Shows how to make unipartite projections of the graph and compute the
+properties of those graphs.
+
+These data were collected by Davis et al. in the 1930s.
+They represent observed attendance at 14 social events by 18 Southern women.
+The graph is bipartite (clubs, women).
+"""
+import matplotlib.pyplot as plt
+import networkx as nx
+import networkx.algorithms.bipartite as bipartite
+
+G = nx.davis_southern_women_graph()
+women = G.graph['top']
+clubs = G.graph['bottom']
+
+print("Biadjacency matrix")
+print(bipartite.biadjacency_matrix(G, women, clubs))
+
+# project bipartite graph onto women nodes
+W = bipartite.projected_graph(G, women)
+print('')
+print("#Friends, Member")
+for w in women:
+    print('%d %s' % (W.degree(w), w))
+
+# project bipartite graph onto women nodes keeping number of co-occurence
+# the degree computed is weighted and counts the total number of shared contacts
+W = bipartite.weighted_projected_graph(G, women)
+print('')
+print("#Friend meetings, Member")
+for w in women:
+    print('%d %s' % (W.degree(w, weight='weight'), w))
+
+nx.draw(G)
+plt.show()

venv/share/doc/networkx-2.4/examples/algorithms/plot_krackhardt_centrality.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+"""
+=====================
+Krackhardt Centrality
+=====================
+
+Centrality measures of Krackhardt social network.
+"""
+# Author: Aric Hagberg (hagberg@lanl.gov)
+# Date: 2005-05-12 14:33:11 -0600 (Thu, 12 May 2005)
+# Revision: 998
+
+#    Copyright (C) 2004-2019 by
+#    Aric Hagberg <hagberg@lanl.gov>
+#    Dan Schult <dschult@colgate.edu>
+#    Pieter Swart <swart@lanl.gov>
+#    All rights reserved.
+#    BSD license.
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+G = nx.krackhardt_kite_graph()
+
+print("Betweenness")
+b = nx.betweenness_centrality(G)
+for v in G.nodes():
+    print("%0.2d %5.3f" % (v, b[v]))
+
+print("Degree centrality")
+d = nx.degree_centrality(G)
+for v in G.nodes():
+    print("%0.2d %5.3f" % (v, d[v]))
+
+print("Closeness centrality")
+c = nx.closeness_centrality(G)
+for v in G.nodes():
+    print("%0.2d %5.3f" % (v, c[v]))
+
+nx.draw(G)
+plt.show()

venv/share/doc/networkx-2.4/examples/algorithms/plot_rcm.py

@@ -0,0 +1,38 @@
+"""
+===
+Rcm
+===
+
+Cuthill-McKee ordering of matrices
+
+The reverse Cuthill-McKee algorithm gives a sparse matrix ordering that
+reduces the matrix bandwidth.
+"""
+
+# Copyright (C) 2011-2019 by
+# Author:    Aric Hagberg <aric.hagberg@gmail.com>
+# BSD License
+import networkx as nx
+from networkx.utils import reverse_cuthill_mckee_ordering
+import numpy as np
+
+# build low-bandwidth numpy matrix
+G = nx.grid_2d_graph(3, 3)
+rcm = list(reverse_cuthill_mckee_ordering(G))
+print("ordering", rcm)
+
+print("unordered Laplacian matrix")
+A = nx.laplacian_matrix(G)
+x, y = np.nonzero(A)
+#print("lower bandwidth:",(y-x).max())
+#print("upper bandwidth:",(x-y).max())
+print("bandwidth: %d" % ((y - x).max() + (x - y).max() + 1))
+print(A)
+
+B = nx.laplacian_matrix(G, nodelist=rcm)
+print("low-bandwidth Laplacian matrix")
+x, y = np.nonzero(B)
+#print("lower bandwidth:",(y-x).max())
+#print("upper bandwidth:",(x-y).max())
+print("bandwidth: %d" % ((y - x).max() + (x - y).max() + 1))
+print(B)

venv/share/doc/networkx-2.4/examples/basic/README.txt

@@ -0,0 +1,2 @@
+Basic
+-----