# About
`SDL_bgi` is a graphics library (`GRAPHICS.H`) for C, C++,
WebAssembly, and Python. It's based on SDL2 and it's portable on many
platforms.
Its name refers to BGI, the Borland Graphics Interface that was the
'de facto' standard in PC graphics back in DOS days; it was made
popular by Borland Turbo C/C++ compilers. I wrote `SDL_bgi` because I
wanted a simple to use but fast graphics library for my experiments
with fractals and cellular automata, using the BGI syntax I'm used to.
`SDL_bgi` is functionally compatible with the BGI implementation in
Turbo C 2.01 and Borland C++ 1.0; for instance, it compiles and runs
the original `bgidemo.c`. `SDL_bgi` also provides nearly full
compatibility with another BGI implementation, WinBGIm (see links
below). One of the aims of `SDL_bgi` is the preservation of old
software written for BGI; but not only that.
`SDL_bgi` provides graphics primitives, and is much easier to use than
plain SDL2; it should be especially useful for beginners, i.e. in
introductory programming courses. `SDL_bgi` is pretty fast, and in
addition to BGI compatibility it provides extensions for ARGB colours,
mouse support, vector fonts, and multiple windows. Native SDL2
functions can be used alongside `SDL_bgi` functions. `SDL_bgi` can
also be used in programs written in C++ or Python.
`SDL_bgi` is written in C, and it should compile on any platform
supported by SDL2. It has been tested on GNU/Linux, MS Windows (MSYS2
and Mingw-w64, CodeBlocks, Dev-C++), macOS (High Sierra and Catalina),
Raspios (ARM, i386), and WebAssembly (Emscripten). A few example
programs in C and Python are provided in the `demo/` directory.
## Requirements
The C version requires the SDL2 library development packages. The
Python module requires the `SDL_bgi` binaries and the SDL2 library
binaries.
## How to Install
Once the dependencies above are met, just do:
```
$ pip install sdl_bgi
```
# How to use `SDL_bgi` in Python programs
Please make sure that you installed the `SDL_bgi` binaries for your
platform before proceeding.
## Implementation Details
`SDL_bgi` Python bindings are implemented via
the [ctypes](https://docs.python.org/3/library/ctypes.html) library.
In general:
- functions in Python have the same name as their C counterparts;
- constants and enums are implemented as variables;
- standard C types (`int`, `float`, `char *`, etc.) are mapped to
Python types;
- structs are available as `ctypes` classes that have the same name
and field names. For example:
\small
```
C struct Python class
-------- ------------
struct arccoordstype { class arccoordstype (Structure):
int x; _fields_ = [ ("x", c_int),
int y; ("y", c_int),
int xstart; ("xstart", c_int)
int ystart; ("ystart", c_int)
int xend; ("xend", c_int),
int yend; ("yend", c_int) ]
};
```
\normalsize
There are minor differences explained below.
## Syntax differences
`ctypes` implements new types that are mapped to equivalent Python
types; for example, `c_int` is equivalent to `int`. Please refer to
`ctypes`'
[Reference](https://docs.python.org/3/library/ctypes.html#fundamental-data-types).
2D arrays can be implemented via [Numpy](https://numpy.org/); please
see for example `demo/life.py` or `demo/buffers_numpy.py`. Strictly
speaking, Numpy is not required; but working with arrays without it is
a pain.
Memory buffers, used for example by `getimage()` or `getbuffer()`, are
implemented using function `create_string_buffer()`.
The `byref()` function can be used to pass variables by reference, as
in the following functions:
\small
```
# void detectgraph (int *graphdriver, int *graphmode);
graphdriver, graphmode = c_int (), c_int ()
detectgraph (byref (graphdriver), byref (graphmode))
print ("graphdriver, graphmode: ", graphdriver.value, graphmode.value)
# void getarccoords (struct arccoordstype *arccoords);
ac = arccoordstype ()
getarccoords (byref (ac))
print ("x, y, xstart, ystart, xend, yend: ", ac.x, ac.y,
ac.xstart, ac.ystart, ac.xend, ac.yend)
# void getaspectratio (int *xasp, int *yasp);
xasp, yasp = c_int (), c_int ()
getaspectratio (byref (xasp), byref (yasp))
print ("xasp, yasp: ", xasp.value, yasp.value)
# void getfillsettings (struct fillsettingstype *fillinfo);
fillinfo = fillsettingstype ()
getfillsettings (byref (fillinfo))
print ("pattern, color: ", fillinfo.pattern, fillinfo.color)
# void getimage ()
isize = imagesize (0, 0, len, 16)
image = create_string_buffer (isize)
getimage (0, 0, len, 16, image)
# void getlinesettings (struct linesettingstype *lineinfo);
lineinfo = linesettingstype ()
getlinesettings (byref (lineinfo))
print ("linestyle, thickness: ", ls.linestyle, ls.thickness)
# void getmoderange (int graphdriver, int *lomode, int *himode);
lomode, himode = c_int (), c_int ()
getmoderange (0, byref (lomode), byref (himode))
print ("lomode, himode: ", lomode.value, lomode.value)
# void getmouseclick (int btn, int *x, int *y);
kind, x, y = c_int (), c_int (), c_int ()
getmouseclick (kind, byref (x), byref (y))
print ("mouse x, mouse y: ", x.value, y.value)
# void getscreensize (int x, int y);
x, y = c_int (), c_int ()
getscreensize (byref (x), byref (y))
print ("size x, size y: ", x, y)
```
\normalsize
## Pythonic Syntax
The following functions provide a more Pytonic syntax that only uses
standard Python types:
\small
```
# void detectgraph (int *graphdriver, int *graphmode);
graphdriver, graphmode = detectgraph ()
print ("graphdriver, graphmode: ", graphdriver, graphmode);
# void getarccoords (struct arccoordstype *arccoords);
ac = arccoordstype ()
ac = getarccoords ()
print ("x, y, xstart, ystart, xend, yend: ", ac.x, ac.y,
ac.xstart, ac.ystart, ac.xend, ac.yend)
# void getaspectratio (int *xasp, int *yasp);
xasp, yasp = getaspectratio ()
print ("xasp, yasp: ", xasp, yasp)
# void getfillsettings (struct fillsettingstype *fillinfo);
fs = fillsettingstype ()
fs = getfillsettings ()
print ("pattern, color: ", fs.pattern, fs.color)
# void getlinesettings (struct linesettingstype *lineinfo);
ls = linesettingstype ()
ls = getlinesettings ()
print ("linestyle, thickness: ", ls.linestyle, ls.thickness)
# void getmoderange (int graphdriver, int *lomode, int *himode);
lomode, himode = getmoderange ()
print ("lomode, himode: ", lomode, lomode)
# void getmouseclick (int btn, int *x, int *y);
x, y = getmouseclick (WM_LBUTTONDOWN)
print ("mouse x, mouse y: ", x, y)
# void getscreensize (int x, int y);
x, y = getscreensize ()
print ("size x, size y: ", x, y)
# void initgraph (int *graphdriver, int *graphmode, char *pathtodriver)
initgraph ()
```
\normalsize
## Helper Functions
The following functions can be useful:
`list2vec (list)`: converts a Python list of integers to a vector;
used for example by `drawpoly()`
`vec2buf (vector)`: returns a string buffer that contains the values
stored in `vector`. This is a 1-dimensional array that can be obtained
from a Numpy 2D array 'matrix' with `reshape (matrix, -1)`.
`sizeofint ()`: equivalent to C `sizeof (int)`. Please note that this
is not the same as `sys.getsizeof()`!
## Missing Features
SDL2-based variables `bgi_window`, `bgi_renderer`, `bgi_texture`,
`PALETTE_SIZE`, and function `copysurface()` are not available.
## Speeding Things Up
Python is an interpreted language, and its performance is quite poor
if compared to compiled code. The [PyPy](https://www.pypy.org)
interpreter should make Python code run faster, but `SDL_bgi` programs
run much slower with PyPy than with CPython. Another Python
implementation, [Pyston](https://www.pyston.org), actually runs
`SDL_bgi` programs definitely faster than CPython.
To give your programs a real boost, I strongly suggest that module
[Numba](https://numba.pydata.org/) be used. Numba is a high
performance Python JIT compiler that can translate a large subset of
Python and NumPy code into fast machine code. It uses simple function
decorators; please have a look at `demo/mandelbrot.py` to see how it
works.
## Making Standalone Binaries
To deploy a Python program as a standalone executable file, you may use
[PyInstaller](https://pyinstaller.org) or [Nuitka](https://nuitka.net/).
### Pyinstaller
Run it as in the following example:
```
test$ pyinstaller -F fern.py
121 INFO: PyInstaller: 5.4.1
121 INFO: Python: 3.10.4
...
7373 INFO: Building EXE from EXE-00.toc completed successfully.
test$ _
```
The resulting executable will be created in directory `dist/`.
### Nuitka
Run it as in the following example:
```
test$ nuitka3 --onefile --remove-output fern.py
Nuitka-Options:INFO: Used command line options: --onefile \
--remove-output fern.py
Nuitka:INFO: Starting Python compilation with Nuitka '1.1.3' \
on Python '3.10' commercial grade 'not installed'.
...
Nuitka:INFO: Successfully created 'fern.bin'.
test$ _
```
When run on Windows, you get `fern.exe` and `fern.cmd`, which is a
batch file that sets up the proper runtime environment for the
executable. Run `fern.cmd` to start the program; on MSYS2, use:
```
test$ start fern.cmd
```
On my GNU/Linux Mint 21.2 box, Nuitka creates a much smaller
executable than Pyinstaller does.
# Links
0. `SDL_bgi` home page:
<https://sdl-bgi.sourceforge.io/>;
<https://pypi.org/project/sdl-bgi>
1. The SDL library:
<https://www.libsdl.org/>
2. BGI on Wikipedia:
<https://en.wikipedia.org/wiki/Borland_Graphics_Interface>
3. WinBGIm, a BGI port for Windows:
<https://winbgim.codecutter.org/>
4. Borland Turbo C 2.01 online emulator:
<https://archive.org/details/msdos_borland_turbo_c_2.01>
5. PyEasyGraphics, a BGI-like Python port:
<https://github.com/royqh1979/PyEasyGraphics>
This library is released under the Zlib license; please see the
enclosed file LICENSE.
Brought to you by Guido Gonzato, PhD
<guido dot gonzato at gmail dot com>
Raw data
{
"_id": null,
"home_page": null,
"name": "sdl-bgi",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "BGI, GRAPHICS.H, SDL2",
"author": null,
"author_email": "\"Guido Gonzato, PhD\" <guido.gonzato@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/cb/52/56ad4f84cc69e358ed019189711e06935b4c8a9c20e2629fb89f42d68fa5/sdl_bgi-3.0.2.tar.gz",
"platform": null,
"description": "# About\n\n`SDL_bgi` is a graphics library (`GRAPHICS.H`) for C, C++,\nWebAssembly, and Python. It's based on SDL2 and it's portable on many\nplatforms.\n\nIts name refers to BGI, the Borland Graphics Interface that was the\n'de facto' standard in PC graphics back in DOS days; it was made\npopular by Borland Turbo C/C++ compilers. I wrote `SDL_bgi` because I\nwanted a simple to use but fast graphics library for my experiments\nwith fractals and cellular automata, using the BGI syntax I'm used to.\n\n`SDL_bgi` is functionally compatible with the BGI implementation in\nTurbo C 2.01 and Borland C++ 1.0; for instance, it compiles and runs\nthe original `bgidemo.c`. `SDL_bgi` also provides nearly full\ncompatibility with another BGI implementation, WinBGIm (see links\nbelow). One of the aims of `SDL_bgi` is the preservation of old\nsoftware written for BGI; but not only that.\n\n`SDL_bgi` provides graphics primitives, and is much easier to use than\nplain SDL2; it should be especially useful for beginners, i.e. in\nintroductory programming courses. `SDL_bgi` is pretty fast, and in\naddition to BGI compatibility it provides extensions for ARGB colours,\nmouse support, vector fonts, and multiple windows. Native SDL2\nfunctions can be used alongside `SDL_bgi` functions. `SDL_bgi` can\nalso be used in programs written in C++ or Python.\n\n`SDL_bgi` is written in C, and it should compile on any platform\nsupported by SDL2. It has been tested on GNU/Linux, MS Windows (MSYS2\nand Mingw-w64, CodeBlocks, Dev-C++), macOS (High Sierra and Catalina),\nRaspios (ARM, i386), and WebAssembly (Emscripten). A few example\nprograms in C and Python are provided in the `demo/` directory.\n\n\n## Requirements\n\nThe C version requires the SDL2 library development packages. The\nPython module requires the `SDL_bgi` binaries and the SDL2 library\nbinaries.\n\n\n## How to Install\n\nOnce the dependencies above are met, just do:\n\n```\n$ pip install sdl_bgi\n```\n\n# How to use `SDL_bgi` in Python programs\n\nPlease make sure that you installed the `SDL_bgi` binaries for your\nplatform before proceeding.\n\n\n## Implementation Details\n\n`SDL_bgi` Python bindings are implemented via\nthe [ctypes](https://docs.python.org/3/library/ctypes.html) library.\nIn general:\n\n- functions in Python have the same name as their C counterparts;\n\n- constants and enums are implemented as variables;\n\n- standard C types (`int`, `float`, `char *`, etc.) are mapped to\n Python types;\n\n- structs are available as `ctypes` classes that have the same name\nand field names. For example:\n\n\\small\n\n```\nC struct Python class\n-------- ------------\nstruct arccoordstype { class arccoordstype (Structure):\n int x; _fields_ = [ (\"x\", c_int), \n int y; (\"y\", c_int), \n int xstart; (\"xstart\", c_int)\n int ystart; (\"ystart\", c_int)\n int xend; (\"xend\", c_int), \n int yend; (\"yend\", c_int) ]\n};\n```\n\\normalsize\n\n\nThere are minor differences explained below.\n\n\n## Syntax differences\n\n`ctypes` implements new types that are mapped to equivalent Python\ntypes; for example, `c_int` is equivalent to `int`. Please refer to\n`ctypes`'\n[Reference](https://docs.python.org/3/library/ctypes.html#fundamental-data-types).\n\n2D arrays can be implemented via [Numpy](https://numpy.org/); please\nsee for example `demo/life.py` or `demo/buffers_numpy.py`. Strictly\nspeaking, Numpy is not required; but working with arrays without it is\na pain.\n\nMemory buffers, used for example by `getimage()` or `getbuffer()`, are\nimplemented using function `create_string_buffer()`.\n\nThe `byref()` function can be used to pass variables by reference, as\nin the following functions:\n\n\\small\n\n```\n# void detectgraph (int *graphdriver, int *graphmode);\ngraphdriver, graphmode = c_int (), c_int ()\ndetectgraph (byref (graphdriver), byref (graphmode))\nprint (\"graphdriver, graphmode: \", graphdriver.value, graphmode.value)\n\n# void getarccoords (struct arccoordstype *arccoords);\nac = arccoordstype ()\ngetarccoords (byref (ac))\nprint (\"x, y, xstart, ystart, xend, yend: \", ac.x, ac.y, \n ac.xstart, ac.ystart, ac.xend, ac.yend)\n\n# void getaspectratio (int *xasp, int *yasp);\nxasp, yasp = c_int (), c_int ()\ngetaspectratio (byref (xasp), byref (yasp))\nprint (\"xasp, yasp: \", xasp.value, yasp.value)\n\n# void getfillsettings (struct fillsettingstype *fillinfo);\nfillinfo = fillsettingstype ()\ngetfillsettings (byref (fillinfo))\nprint (\"pattern, color: \", fillinfo.pattern, fillinfo.color)\n\n# void getimage ()\nisize = imagesize (0, 0, len, 16)\nimage = create_string_buffer (isize)\ngetimage (0, 0, len, 16, image)\n\n# void getlinesettings (struct linesettingstype *lineinfo);\nlineinfo = linesettingstype ()\ngetlinesettings (byref (lineinfo))\nprint (\"linestyle, thickness: \", ls.linestyle, ls.thickness)\n\n# void getmoderange (int graphdriver, int *lomode, int *himode);\nlomode, himode = c_int (), c_int ()\ngetmoderange (0, byref (lomode), byref (himode))\nprint (\"lomode, himode: \", lomode.value, lomode.value)\n\n# void getmouseclick (int btn, int *x, int *y);\nkind, x, y = c_int (), c_int (), c_int ()\ngetmouseclick (kind, byref (x), byref (y))\nprint (\"mouse x, mouse y: \", x.value, y.value)\n\n# void getscreensize (int x, int y);\nx, y = c_int (), c_int ()\ngetscreensize (byref (x), byref (y))\nprint (\"size x, size y: \", x, y)\n```\n\n\\normalsize\n\n## Pythonic Syntax\n\nThe following functions provide a more Pytonic syntax that only uses\nstandard Python types:\n\n\\small\n\n```\n# void detectgraph (int *graphdriver, int *graphmode);\ngraphdriver, graphmode = detectgraph ()\nprint (\"graphdriver, graphmode: \", graphdriver, graphmode);\n\n# void getarccoords (struct arccoordstype *arccoords);\nac = arccoordstype ()\nac = getarccoords ()\nprint (\"x, y, xstart, ystart, xend, yend: \", ac.x, ac.y, \n ac.xstart, ac.ystart, ac.xend, ac.yend)\n\n# void getaspectratio (int *xasp, int *yasp);\nxasp, yasp = getaspectratio ()\nprint (\"xasp, yasp: \", xasp, yasp)\n\n# void getfillsettings (struct fillsettingstype *fillinfo);\nfs = fillsettingstype ()\nfs = getfillsettings ()\nprint (\"pattern, color: \", fs.pattern, fs.color)\n\n# void getlinesettings (struct linesettingstype *lineinfo);\nls = linesettingstype ()\nls = getlinesettings ()\nprint (\"linestyle, thickness: \", ls.linestyle, ls.thickness)\n\n# void getmoderange (int graphdriver, int *lomode, int *himode);\nlomode, himode = getmoderange ()\nprint (\"lomode, himode: \", lomode, lomode)\n\n# void getmouseclick (int btn, int *x, int *y);\nx, y = getmouseclick (WM_LBUTTONDOWN)\nprint (\"mouse x, mouse y: \", x, y)\n\n# void getscreensize (int x, int y);\nx, y = getscreensize ()\nprint (\"size x, size y: \", x, y)\n\n# void initgraph (int *graphdriver, int *graphmode, char *pathtodriver)\ninitgraph ()\n```\n\n\\normalsize\n\n## Helper Functions\n\nThe following functions can be useful:\n\n`list2vec (list)`: converts a Python list of integers to a vector;\nused for example by `drawpoly()`\n\n`vec2buf (vector)`: returns a string buffer that contains the values\nstored in `vector`. This is a 1-dimensional array that can be obtained\nfrom a Numpy 2D array 'matrix' with `reshape (matrix, -1)`.\n\n`sizeofint ()`: equivalent to C `sizeof (int)`. Please note that this\nis not the same as `sys.getsizeof()`!\n\n\n## Missing Features\n\nSDL2-based variables `bgi_window`, `bgi_renderer`, `bgi_texture`,\n`PALETTE_SIZE`, and function `copysurface()` are not available.\n\n\n## Speeding Things Up\n\nPython is an interpreted language, and its performance is quite poor\nif compared to compiled code. The [PyPy](https://www.pypy.org)\ninterpreter should make Python code run faster, but `SDL_bgi` programs\nrun much slower with PyPy than with CPython. Another Python\nimplementation, [Pyston](https://www.pyston.org), actually runs\n`SDL_bgi` programs definitely faster than CPython.\n\nTo give your programs a real boost, I strongly suggest that module\n[Numba](https://numba.pydata.org/) be used. Numba is a high\nperformance Python JIT compiler that can translate a large subset of\nPython and NumPy code into fast machine code. It uses simple function\ndecorators; please have a look at `demo/mandelbrot.py` to see how it\nworks.\n\n\n## Making Standalone Binaries\n\nTo deploy a Python program as a standalone executable file, you may use \n[PyInstaller](https://pyinstaller.org) or [Nuitka](https://nuitka.net/).\n\n### Pyinstaller\n\nRun it as in the following example:\n\n```\ntest$ pyinstaller -F fern.py \n121 INFO: PyInstaller: 5.4.1\n121 INFO: Python: 3.10.4\n...\n7373 INFO: Building EXE from EXE-00.toc completed successfully.\ntest$ _\n```\n\nThe resulting executable will be created in directory `dist/`.\n\n### Nuitka\n\nRun it as in the following example:\n\n```\ntest$ nuitka3 --onefile --remove-output fern.py\nNuitka-Options:INFO: Used command line options: --onefile \\\n --remove-output fern.py\nNuitka:INFO: Starting Python compilation with Nuitka '1.1.3' \\\n on Python '3.10' commercial grade 'not installed'.\n...\nNuitka:INFO: Successfully created 'fern.bin'.\ntest$ _\n```\n\nWhen run on Windows, you get `fern.exe` and `fern.cmd`, which is a\nbatch file that sets up the proper runtime environment for the\nexecutable. Run `fern.cmd` to start the program; on MSYS2, use:\n\n```\ntest$ start fern.cmd\n```\n\nOn my GNU/Linux Mint 21.2 box, Nuitka creates a much smaller\nexecutable than Pyinstaller does.\n\n\n# Links\n\n0. `SDL_bgi` home page:\n <https://sdl-bgi.sourceforge.io/>;\n <https://pypi.org/project/sdl-bgi>\n\n1. The SDL library:\n <https://www.libsdl.org/>\n\n2. BGI on Wikipedia:\n <https://en.wikipedia.org/wiki/Borland_Graphics_Interface>\n\n3. WinBGIm, a BGI port for Windows:\n <https://winbgim.codecutter.org/>\n\n4. Borland Turbo C 2.01 online emulator:\n <https://archive.org/details/msdos_borland_turbo_c_2.01>\n\n5. PyEasyGraphics, a BGI-like Python port:\n <https://github.com/royqh1979/PyEasyGraphics>\n\nThis library is released under the Zlib license; please see the\nenclosed file LICENSE.\n\nBrought to you by Guido Gonzato, PhD\n<guido dot gonzato at gmail dot com>\n",
"bugtrack_url": null,
"license": "// ZLib License Copyright (c) 2014-2024 Guido Gonzato, PhD This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. ",
"summary": "SDL2-based 'GRAPHICS.H' implementation",
"version": "3.0.2",
"project_urls": {
"Homepage": "https://sdl-bgi.sourceforge.io/"
},
"split_keywords": [
"bgi",
" graphics.h",
" sdl2"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "4870dc46f25188c614a4ac0c274549ecdf2eabcaec5c4fd38ed9917f085136ee",
"md5": "cfa550035fea7e8741f6576f6d6ac8f5",
"sha256": "dd77d19707f65dfcfe78b20c1b7bdefdd72a29632c5a277872fcc0ec926d7aa0"
},
"downloads": -1,
"filename": "sdl_bgi-3.0.2-py3-none-any.whl",
"has_sig": false,
"md5_digest": "cfa550035fea7e8741f6576f6d6ac8f5",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 17695,
"upload_time": "2024-04-30T09:54:55",
"upload_time_iso_8601": "2024-04-30T09:54:55.285654Z",
"url": "https://files.pythonhosted.org/packages/48/70/dc46f25188c614a4ac0c274549ecdf2eabcaec5c4fd38ed9917f085136ee/sdl_bgi-3.0.2-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "cb5256ad4f84cc69e358ed019189711e06935b4c8a9c20e2629fb89f42d68fa5",
"md5": "ff31a139b5dfd496562008ca0955823a",
"sha256": "856b86d83459d79ba5b2bb89fc5cf09fee1cebb06beab058ada71d860278b155"
},
"downloads": -1,
"filename": "sdl_bgi-3.0.2.tar.gz",
"has_sig": false,
"md5_digest": "ff31a139b5dfd496562008ca0955823a",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 29521,
"upload_time": "2024-04-30T09:54:56",
"upload_time_iso_8601": "2024-04-30T09:54:56.503092Z",
"url": "https://files.pythonhosted.org/packages/cb/52/56ad4f84cc69e358ed019189711e06935b4c8a9c20e2629fb89f42d68fa5/sdl_bgi-3.0.2.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-04-30 09:54:56",
"github": false,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"lcname": "sdl-bgi"
}
