133 lines
5.9 KiB
C
133 lines
5.9 KiB
C
/* SPDX-License-Identifier: GPL-3.0-or-later OR BSD-2-Clause */
|
|
/* Copyright (c) 2026 Eremey Valetov. See LICENSES/BSD-2-Clause.txt. */
|
|
#define PY_SSIZE_T_CLEAN
|
|
#include <Python.h>
|
|
#include <uc2/uc2_writer.h>
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
uc2_writer *writer;
|
|
int busy, initialized;
|
|
} Writer;
|
|
static int available(Writer *self)
|
|
{
|
|
if (self->busy) { PyErr_SetString(PyExc_RuntimeError,"writer is already in use"); return 0; }
|
|
if (!self->writer) { PyErr_SetString(PyExc_ValueError,"writer is closed"); return 0; }
|
|
return 1;
|
|
}
|
|
static void set_error(Writer *self, int result)
|
|
{
|
|
if (PyErr_Occurred()) return;
|
|
PyObject *type=PyExc_OSError;
|
|
if (result==UC2_WRITER_LIMIT) {
|
|
PyObject *module=PyType_GetModule(Py_TYPE(self));
|
|
PyObject *exception=PyObject_GetAttrString(module,"ResourceLimitError");
|
|
if (exception) { PyErr_SetString(exception,uc2_writer_error(self->writer)); Py_DECREF(exception); }
|
|
return;
|
|
}
|
|
if (result==UC2_WRITER_INVALID || result==UC2_BadState) type=PyExc_ValueError;
|
|
PyErr_SetString(type,uc2_writer_error(self->writer));
|
|
}
|
|
static int writer_init(Writer *self, PyObject *args, PyObject *kwargs)
|
|
{
|
|
int level=4; unsigned maximum=100000; long long total=UINT32_MAX;
|
|
static char *names[]={"level","max_entries","max_total_size",NULL};
|
|
if (self->initialized) { PyErr_SetString(PyExc_RuntimeError,"writer cannot be initialized twice"); return -1; }
|
|
if (!PyArg_ParseTupleAndKeywords(args,kwargs,"|iIL",names,&level,&maximum,&total)) return -1;
|
|
if (level<2 || level>9 || maximum<1 || maximum>1000000 || total<1 || total>UINT32_MAX) {
|
|
PyErr_SetString(PyExc_ValueError,"invalid writer level or limits"); return -1;
|
|
}
|
|
struct uc2_writer_options options={level,maximum,(uint64_t)total};
|
|
self->initialized=1; self->writer=uc2_writer_create(&options);
|
|
if (!self->writer) { PyErr_SetString(PyExc_OSError,"cannot allocate writer or create temporary input file"); return -1; }
|
|
return 0;
|
|
}
|
|
static void writer_dealloc(Writer *self)
|
|
{
|
|
PyTypeObject *type=Py_TYPE(self);
|
|
uc2_writer_free(self->writer);
|
|
type->tp_free((PyObject *)self); Py_DECREF(type);
|
|
}
|
|
static PyObject *writer_abort(Writer *self, PyObject *unused)
|
|
{
|
|
if (self->busy) { PyErr_SetString(PyExc_RuntimeError,"writer is already in use"); return NULL; }
|
|
uc2_writer_free(self->writer); self->writer=NULL; Py_RETURN_NONE;
|
|
}
|
|
static PyObject *writer_directory(Writer *self, PyObject *args)
|
|
{
|
|
unsigned parent,time,attr,id; const char *name;
|
|
if (!available(self)) return NULL;
|
|
if (!PyArg_ParseTuple(args,"IsII",&parent,&name,&time,&attr)) return NULL;
|
|
int r=uc2_writer_add_directory(self->writer,parent,name,time,attr,&id);
|
|
if (r<0) { set_error(self,r); return NULL; }
|
|
return PyLong_FromUnsignedLong(id);
|
|
}
|
|
static int read_input(void *ctx, void *data, unsigned len)
|
|
{
|
|
if (PyErr_Occurred() || PyErr_CheckSignals()<0) return -1;
|
|
PyObject *value=PyObject_CallMethod((PyObject *)ctx,"read","I",len);
|
|
if (!value) return -1;
|
|
if (!PyBytes_Check(value) || PyBytes_GET_SIZE(value)>(Py_ssize_t)len) {
|
|
Py_DECREF(value); PyErr_SetString(PyExc_TypeError,"input read() must return bytes, at most the requested length"); return -1;
|
|
}
|
|
int n=(int)PyBytes_GET_SIZE(value);
|
|
memcpy(data,PyBytes_AS_STRING(value),(size_t)n); Py_DECREF(value); return n;
|
|
}
|
|
static PyObject *writer_file(Writer *self, PyObject *args)
|
|
{
|
|
unsigned parent,time,attr; const char *name; PyObject *size,*source;
|
|
if (!available(self)) return NULL;
|
|
if (!PyArg_ParseTuple(args,"IsIIOO",&parent,&name,&time,&attr,&size,&source)) return NULL;
|
|
uint64_t length=UC2_WRITER_UNKNOWN_SIZE;
|
|
if (size!=Py_None) {
|
|
length=PyLong_AsUnsignedLongLong(size); if (PyErr_Occurred()) return NULL;
|
|
if (length>UINT32_MAX) { PyErr_SetString(PyExc_ValueError,"file size exceeds UINT32_MAX"); return NULL; }
|
|
}
|
|
self->busy=1;
|
|
int r=uc2_writer_add_file(self->writer,parent,name,time,attr,length,read_input,source);
|
|
self->busy=0;
|
|
if (r<0 || PyErr_Occurred()) { set_error(self,r); return NULL; }
|
|
Py_RETURN_NONE;
|
|
}
|
|
static int write_output(void *ctx, const void *data, unsigned len)
|
|
{
|
|
if (PyErr_Occurred() || PyErr_CheckSignals()<0) return -1;
|
|
PyObject *value=PyObject_CallMethod((PyObject *)ctx,"write","y#",data,(Py_ssize_t)len);
|
|
if (!value) return -1;
|
|
Py_ssize_t n=PyLong_AsSsize_t(value); Py_DECREF(value);
|
|
if (PyErr_Occurred()) return -1;
|
|
if (n!=(Py_ssize_t)len) { PyErr_SetString(PyExc_OSError,"output write() did not accept the full buffer"); return -1; }
|
|
return 0;
|
|
}
|
|
static PyObject *writer_finish(Writer *self, PyObject *destination)
|
|
{
|
|
if (!available(self)) return NULL;
|
|
self->busy=1;
|
|
int r=uc2_writer_finish(self->writer,write_output,destination);
|
|
self->busy=0;
|
|
if (r<0 || PyErr_Occurred()) { set_error(self,r); return NULL; }
|
|
struct uc2_writer_stats stats; uc2_writer_get_stats(self->writer,&stats);
|
|
uc2_writer_free(self->writer); self->writer=NULL;
|
|
return Py_BuildValue("{sI,sI,sI,sI}","files",stats.files,"directories",stats.directories,
|
|
"masters",stats.masters,"archive_size",stats.archive_size);
|
|
}
|
|
static PyMethodDef methods[]={
|
|
{"abort",(PyCFunction)writer_abort,METH_NOARGS,NULL},
|
|
{"add_directory",(PyCFunction)writer_directory,METH_VARARGS,NULL},
|
|
{"add_file",(PyCFunction)writer_file,METH_VARARGS,NULL},
|
|
{"finish",(PyCFunction)writer_finish,METH_O,NULL}, {NULL,NULL,0,NULL}
|
|
};
|
|
static PyType_Slot slots[]={
|
|
{Py_tp_new,PyType_GenericNew},{Py_tp_init,writer_init},{Py_tp_dealloc,writer_dealloc},
|
|
{Py_tp_methods,methods},{0,NULL}
|
|
};
|
|
static PyType_Spec spec={"uc2._native.Writer",sizeof(Writer),0,Py_TPFLAGS_DEFAULT,slots};
|
|
int uc2_python_writer_init(PyObject *module)
|
|
{
|
|
PyObject *type=PyType_FromModuleAndSpec(module,&spec,NULL);
|
|
if (!type) return -1;
|
|
int r=PyModule_AddObject(module,"Writer",type);
|
|
if (r<0) Py_DECREF(type);
|
|
return r;
|
|
}
|