return 365 + _is_leap(year)
def _days_before_year(year): # number of days before year
- return year*365 + (year+3)/4 - (year+99)/100 + (year+399)/400
+ return year*365 + (year+3)//4 - (year+99)//100 + (year+399)//400
def _days_in_month(month, year): # number of days in month of year
if month == 2 and _is_leap(year): return 29
del ans.ord, ans.month, ans.day, ans.year # un-initialize it
ans.ord = n
- n400 = (n-1)/_DI400Y # # of 400-year blocks preceding
+ n400 = (n-1)//_DI400Y # # of 400-year blocks preceding
year, n = 400 * n400, n - _DI400Y * n400
- more = n / 365
+ more = n // 365
dby = _days_before_year(more)
if dby >= n:
more = more - 1
try: year = int(year) # chop to int, if it fits
except (ValueError, OverflowError): pass
- month = min(n/29 + 1, 12)
+ month = min(n//29 + 1, 12)
dbm = _days_before_month(month, year)
if dbm >= n:
month = month - 1
local = time.localtime(time.time())
return Date(local[1], local[2], local[0])
-DateTestError = 'DateTestError'
+class DateTestError(Exception):
+ pass
+
def test(firstyear, lastyear):
a = Date(9,30,1913)
b = Date(9,30,1914)
(fd.month,fd.day,fd.year,ld.month,ld.day,ld.year):
raise DateTestError('num->date failed', y)
y = y + 1
+
+if __name__ == '__main__':
+ test(1850, 2150)
import sys; rprt = sys.stderr.write #for debugging
-error = 'bitvec.error'
+class error(Exception):
+ pass
def _check_value(value):
filsiz = 1 << 8
filler = makestr(0, filsiz-1)
- data = filler * (TEST_BLOCK_SIZE / filsiz);
+ data = filler * (TEST_BLOCK_SIZE // filsiz)
data = data + filler[:(TEST_BLOCK_SIZE % filsiz)]
del filsiz, filler
def MDFile(filename):
- f = open(filename, 'rb');
+ f = open(filename, 'rb')
mdContext = md5.new()
while 1:
dt = t2-t1
print(size, "bytes in", round(dt), "seconds", end=' ')
if dt:
- print("i.e.", int(size/dt), "bytes/sec", end=' ')
+ print("i.e.", int(size//dt), "bytes/sec", end=' ')
print()
remote._recv(id) # ignored
fh = sf[1]
if fh:
ncl = NFSClient(host)
- print(ncl.Getattr(fh))
+ attrstat = ncl.Getattr(fh)
+ print(attrstat)
list = ncl.Listdir(fh)
for item in list: print(item)
mcl.Umnt(filesys)
# Exceptions
-BadRPCFormat = 'rpc.BadRPCFormat'
-BadRPCVersion = 'rpc.BadRPCVersion'
-GarbageArgs = 'rpc.GarbageArgs'
+class BadRPCFormat(Exception): pass
+class BadRPCVersion(Exception): pass
+class GarbageArgs(Exception): pass
class Unpacker(xdr.Unpacker):
def pack_fstring(self, n, s):
if n < 0:
raise ValueError('fstring size must be nonnegative')
- n = ((n+3)/4)*4
+ n = ((n + 3)//4)*4
data = s[:n]
data = data + (n - len(data)) * '\0'
self.buf = self.buf + data
if n < 0:
raise ValueError('fstring size must be nonnegative')
i = self.pos
- j = i + (n+3)/4*4
+ j = i + (n+3)//4*4
if j > len(self.buf):
raise EOFError
self.pos = j
import sys
from math import sqrt
-error = 'fact.error' # exception
-
def fact(n):
- if n < 1: raise error # fact() argument should be >= 1
+ if n < 1: raise ValueError # fact() argument should be >= 1
if n == 1: return [] # special case
res = []
# Treat even factors special, so we can use i = i+2 later
while n%2 == 0:
res.append(2)
- n = n/2
+ n = n//2
# Try odd numbers up to sqrt(n)
limit = sqrt(float(n+1))
i = 3
while i <= limit:
if n%i == 0:
res.append(i)
- n = n/i
+ n = n//i
limit = sqrt(n+1)
else:
i = i+2
def showbar(dict, title):
n = len(title)
- print('='*((70-n)/2), title, '='*((71-n)/2))
+ print('='*((70-n)//2), title, '='*((71-n)//2))
list = []
for key in sorted(dict.keys()):
n = len(str(key))
if len(dict) > maxitems:
title = title + ' (first %d)'%maxitems
n = len(title)
- print('='*((70-n)/2), title, '='*((71-n)/2))
+ print('='*((70-n)//2), title, '='*((71-n)//2))
list = []
for key in dict.keys():
list.append((-len(dict[key]), key))
lines.append(line)
#
if totaljobs:
- line = '%d K' % ((totalbytes+1023)/1024)
+ line = '%d K' % ((totalbytes+1023)//1024)
if totaljobs != len(users):
line = line + ' (%d jobs)' % totaljobs
if len(users) == 1:
line = line + ' (%s first)' % thisuser
else:
line = line + ' (%d K before %s)' % (
- (aheadbytes+1023)/1024, thisuser)
+ (aheadbytes+1023)//1024, thisuser)
lines.append(line)
#
sts = pipe.close()
def tuple(list):
if len(list) == 0: return ()
if len(list) == 1: return (list[0],)
- i = len(list)/2
+ i = len(list)//2
return tuple(list[:i]) + tuple(list[i:])
if __name__ == "__main__":
tree={}
# Check that the output directory exists
- checkopdir(pagedir);
+ checkopdir(pagedir)
try:
print('Connecting to '+newshost+'...')
p, q, k = k*k, 2*k+1, k+1
a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
# Print common digits
- d, d1 = a/b, a1/b1
+ d, d1 = a//b, a1//b1
while d == d1:
output(d)
a, a1 = 10*(a%b), 10*(a1%b1)
- d, d1 = a/b, a1/b1
+ d, d1 = a//b, a1//b1
def output(d):
# Use write() to avoid spaces between the digits
# was different then...
(year, month, day) = xxx_todo_changeme1
days = year*365 # years, roughly
- days = days + (year+3)/4 # plus leap years, roughly
- days = days - (year+99)/100 # minus non-leap years every century
- days = days + (year+399)/400 # plus leap years every 4 centirues
+ days = days + (year+3)//4 # plus leap years, roughly
+ days = days - (year+99)//100 # minus non-leap years every century
+ days = days + (year+399)//400 # plus leap years every 4 centirues
for i in range(1, month):
if i == 2 and calendar.isleap(year):
days = days + 29
hostname = gethostname()
hostaddr = gethostbyname(hostname)
hbytes = string.splitfields(hostaddr, '.')
- pbytes = [repr(port/256), repr(port%256)]
+ pbytes = [repr(port//256), repr(port%256)]
bytes = hbytes + pbytes
cmd = 'PORT ' + string.joinfields(bytes, ',')
s.send(cmd + '\r\n')
self.e.wait()
self.e.clear()
-Killed = 'Coroutine.Killed'
-EarlyExit = 'Coroutine.EarlyExit'
+class Killed(Exception): pass
+class EarlyExit(Exception): pass
class Coroutine:
def __init__(self):
# Generator implementation using threads
import _thread as thread
+import sys
-Killed = 'Generator.Killed'
+class Killed(Exception):
+ pass
class Generator:
# Constructor
self.done = 0
self.killed = 0
thread.start_new_thread(self._start, ())
+
# Internal routine
def _start(self):
try:
if not self.killed:
self.done = 1
self.getlock.release()
+
# Called by producer for each value; raise Killed if no more needed
def put(self, value):
if self.killed:
self.putlock.acquire() # Wait for next get() call
if self.killed:
raise Killed
+
# Called by producer to get next value; raise EOFError if no more
def get(self):
if self.killed:
if self.done:
raise EOFError # Say there are no more values
return self.value
+
# Called by consumer if no more values wanted
def kill(self):
if self.killed:
raise TypeError('kill() called on killed generator')
self.killed = 1
self.putlock.release()
+
# Clone constructor
def clone(self):
return Generator(self.func, self.args)
p, q, k = k*k, 2*k+1, k+1
a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
# Print common digits
- d, d1 = a/b, a1/b1
+ d, d1 = a//b, a1//b1
while d == d1:
g.put(int(d))
a, a1 = 10*(a%b), 10*(a1%b1)
- d, d1 = a/b, a1/b1
+ d, d1 = a//b, a1//b1
def test():
g = Generator(pi, ())
g.kill()
while 1:
print(h.get(), end=' ')
+ sys.stdout.flush()
test()
# Add background bitmap
if bitmap:
- self.bitmap = c.create_bitmap(width/2, height/2,
+ self.bitmap = c.create_bitmap(width//2, height//2,
bitmap=bitmap,
foreground='blue')
# Generate pegs
pegwidth = 10
- pegheight = height/2
- pegdist = width/3
- x1, y1 = (pegdist-pegwidth)/2, height*1/3
+ pegheight = height//2
+ pegdist = width//3
+ x1, y1 = (pegdist-pegwidth)//2, height*1//3
x2, y2 = x1+pegwidth, y1+pegheight
self.pegs = []
p = c.create_rectangle(x1, y1, x2, y2, fill='black')
self.tk.update()
# Generate pieces
- pieceheight = pegheight/16
- maxpiecewidth = pegdist*2/3
+ pieceheight = pegheight//16
+ maxpiecewidth = pegdist*2//3
minpiecewidth = 2*pegwidth
self.pegstate = [[], [], []]
self.pieces = {}
- x1, y1 = (pegdist-maxpiecewidth)/2, y2-pieceheight-2
+ x1, y1 = (pegdist-maxpiecewidth)//2, y2-pieceheight-2
x2, y2 = x1+maxpiecewidth, y1+pieceheight
- dx = (maxpiecewidth-minpiecewidth) / (2*max(1, n-1))
+ dx = (maxpiecewidth-minpiecewidth) // (2*max(1, n-1))
for i in range(n, 0, -1):
p = c.create_rectangle(x1, y1, x2, y2, fill='red')
self.pieces[i] = p
# Move it towards peg b
bx1, by1, bx2, by2 = c.bbox(self.pegs[b])
- newcenter = (bx1+bx2)/2
+ newcenter = (bx1+bx2)//2
while 1:
x1, y1, x2, y2 = c.bbox(p)
- center = (x1+x2)/2
+ center = (x1+x2)//2
if center == newcenter: break
if center > newcenter: c.move(p, -1, 0)
else: c.move(p, 1, 0)
self.group = Group(canvas)
text = "%s %s" % (VALNAMES[value], suit)
- self.__text = CanvasText(canvas, CARDWIDTH/2, 0,
+ self.__text = CanvasText(canvas, CARDWIDTH//2, 0,
anchor=N, fill=self.color, text=text)
self.group.addtag_withtag(self.__text)
def animatedmoveto(self, card, dest):
for i in range(10, 0, -1):
- dx, dy = (dest.x-card.x)/i, (dest.y-card.y)/i
+ dx, dy = (dest.x-card.x)//i, (dest.y-card.y)//i
card.moveby(dx, dy)
self.master.update_idletasks()
if self.speed == "fastest":
msecs = 0
elif self.speed == "fast":
- msecs = msecs/10
+ msecs = msecs//10
elif self.speed == "single-step":
msecs = 1000000000
if not self.stop_mainloop:
return outcome
def position(self):
- x1 = (self.index+1)*XGRID - WIDTH/2
+ x1 = (self.index+1)*XGRID - WIDTH//2
x2 = x1+WIDTH
y2 = (self.array.maxvalue+1)*YGRID
y1 = y2 - (self.value)*YGRID
res = [tuple(oldpts)]
for i in range(1, n):
for k in range(len(pts)):
- pts[k] = oldpts[k] + (newpts[k] - oldpts[k])*i/n
+ pts[k] = oldpts[k] + (newpts[k] - oldpts[k])*i//n
res.append(tuple(pts))
res.append(tuple(newpts))
return res
def uniform(array):
size = array.getsize()
- array.setdata([(size+1)/2] * size)
+ array.setdata([(size+1)//2] * size)
array.reset("Uniform data, size %d" % size)
def distinct(array):
j = j-1
continue
array.message("Choosing pivot")
- j, i, k = first, (first+last)/2, last-1
+ j, i, k = first, (first+last)//2, last-1
if array.compare(k, i) < 0:
array.swap(k, i)
if array.compare(k, j) < 0:
:Release: |version|
:Date: |today|
-While the :ref:`reference-index` describes the exact syntax and
+While :ref:`reference-index` describes the exact syntax and
semantics of the Python language, this library reference manual
describes the standard library that is distributed with Python. It also
describes some of the optional components that are commonly included
Additional Methods on Float
---------------------------
-The float type has some additional methods to support conversion to
+The float type has some additional methods.
+
+.. method:: float.as_integer_ratio()
+
+ Return a pair of integers whose ratio is exactly equal to the
+ original float and with a positive denominator. Raises
+ :exc:`OverflowError` on infinities and a :exc:`ValueError` on
+ NaNs.
+
+ .. versionadded:: 2.6
+
+Two methods support conversion to
and from hexadecimal strings. Since Python's floats are stored
internally as binary numbers, converting a float to or from a
*decimal* string usually involves a small rounding error. In
| | positive numbers, and a minus sign on negative numbers. |
+---------+----------------------------------------------------------+
-The ``'#'`` option is only valid for integers, and only for binary,
-octal, or hexadecimal output. If present, it specifies that the output
-will be prefixed by ``'0b'``, ``'0o'``, or ``'0x'``, respectively.
+The ``'#'`` option is only valid for integers, and only for binary, octal, or
+hexadecimal output. If present, it specifies that the output will be prefixed
+by ``'0b'``, ``'0o'``, or ``'0x'``, respectively.
*width* is a decimal integer defining the minimum field width. If not
specified, then the field width will be determined by the content.
.. _reference-index:
#################################
- The Python language reference
+ The Python Language Reference
#################################
:Release: |version|
.. _tutorial-index:
######################
- The Python tutorial
+ The Python Tutorial
######################
:Release: |version|
static int pysqlite_connection_set_isolation_level(pysqlite_Connection* self, PyObject* isolation_level);
-void _sqlite3_result_error(sqlite3_context* ctx, const char* errmsg, int len)
+static void _sqlite3_result_error(sqlite3_context* ctx, const char* errmsg, int len)
{
/* in older SQLite versions, calling sqlite3_result_error in callbacks
* triggers a bug in SQLite that leads either to irritating results or
goto error;
}
- rc = _sqlite_step_with_busyhandler(statement, self);
+ rc = pysqlite_step(statement, self);
if (rc == SQLITE_DONE) {
self->inTransaction = 1;
} else {
goto error;
}
- rc = _sqlite_step_with_busyhandler(statement, self);
+ rc = pysqlite_step(statement, self);
if (rc == SQLITE_DONE) {
self->inTransaction = 0;
} else {
goto error;
}
- rc = _sqlite_step_with_busyhandler(statement, self);
+ rc = pysqlite_step(statement, self);
if (rc == SQLITE_DONE) {
self->inTransaction = 0;
} else {
{"interrupt", (PyCFunction)pysqlite_connection_interrupt, METH_NOARGS,
PyDoc_STR("Abort any pending database operation. Non-standard.")},
{"iterdump", (PyCFunction)pysqlite_connection_iterdump, METH_NOARGS,
- PyDoc_STR("Returns iterator to the dump of the database in an SQL text"
- "format.")},
+ PyDoc_STR("Returns iterator to the dump of the database in an SQL text format. Non-standard.")},
{"__enter__", (PyCFunction)pysqlite_connection_enter, METH_NOARGS,
PyDoc_STR("For context manager. Non-standard.")},
{"__exit__", (PyCFunction)pysqlite_connection_exit, METH_VARARGS,
/* Keep trying the SQL statement until the schema stops changing. */
while (1) {
/* Actually execute the SQL statement. */
- rc = _sqlite_step_with_busyhandler(self->statement->st, self->connection);
+ rc = pysqlite_step(self->statement->st, self->connection);
if (rc == SQLITE_DONE || rc == SQLITE_ROW) {
/* If it worked, let's get out of the loop */
break;
}
statement_completed = 1;
+ Py_BEGIN_ALLOW_THREADS
rc = sqlite3_prepare(self->connection->db,
script_cstr,
-1,
&statement,
&script_cstr);
+ Py_END_ALLOW_THREADS
if (rc != SQLITE_OK) {
_pysqlite_seterror(self->connection->db, NULL);
goto error;
/* execute statement, and ignore results of SELECT statements */
rc = SQLITE_ROW;
while (rc == SQLITE_ROW) {
- rc = _sqlite_step_with_busyhandler(statement, self->connection);
+ rc = pysqlite_step(statement, self->connection);
/* TODO: we probably need more error handling here */
}
}
if (self->statement) {
- rc = _sqlite_step_with_busyhandler(self->statement->st, self->connection);
+ rc = pysqlite_step(self->statement->st, self->connection);
if (rc != SQLITE_DONE && rc != SQLITE_ROW) {
(void)pysqlite_statement_reset(self->statement);
Py_DECREF(next_row);
PyObject *psyco_adapters;
-/* microprotocols_init - initialize the adapters dictionary */
+/* pysqlite_microprotocols_init - initialize the adapters dictionary */
int
-microprotocols_init(PyObject *dict)
+pysqlite_microprotocols_init(PyObject *dict)
{
/* create adapters dictionary and put it in module namespace */
if ((psyco_adapters = PyDict_New()) == NULL) {
}
-/* microprotocols_add - add a reverse type-caster to the dictionary */
+/* pysqlite_microprotocols_add - add a reverse type-caster to the dictionary */
int
-microprotocols_add(PyTypeObject *type, PyObject *proto, PyObject *cast)
+pysqlite_microprotocols_add(PyTypeObject *type, PyObject *proto, PyObject *cast)
{
PyObject* key;
int rc;
return rc;
}
-/* microprotocols_adapt - adapt an object to the built-in protocol */
+/* pysqlite_microprotocols_adapt - adapt an object to the built-in protocol */
PyObject *
-microprotocols_adapt(PyObject *obj, PyObject *proto, PyObject *alt)
+pysqlite_microprotocols_adapt(PyObject *obj, PyObject *proto, PyObject *alt)
{
PyObject *adapter, *key;
/** module-level functions **/
PyObject *
-psyco_microprotocols_adapt(pysqlite_Cursor *self, PyObject *args)
+pysqlite_adapt(pysqlite_Cursor *self, PyObject *args)
{
PyObject *obj, *alt = NULL;
PyObject *proto = (PyObject*)&pysqlite_PrepareProtocolType;
if (!PyArg_ParseTuple(args, "O|OO", &obj, &proto, &alt)) return NULL;
- return microprotocols_adapt(obj, proto, alt);
+ return pysqlite_microprotocols_adapt(obj, proto, alt);
}
/** exported functions **/
/* used by module.c to init the microprotocols system */
-extern int microprotocols_init(PyObject *dict);
-extern int microprotocols_add(
+extern int pysqlite_microprotocols_init(PyObject *dict);
+extern int pysqlite_microprotocols_add(
PyTypeObject *type, PyObject *proto, PyObject *cast);
-extern PyObject *microprotocols_adapt(
+extern PyObject *pysqlite_microprotocols_adapt(
PyObject *obj, PyObject *proto, PyObject *alt);
extern PyObject *
- psyco_microprotocols_adapt(pysqlite_Cursor* self, PyObject *args);
-#define psyco_microprotocols_adapt_doc \
+ pysqlite_adapt(pysqlite_Cursor* self, PyObject *args);
+#define pysqlite_adapt_doc \
"adapt(obj, protocol, alternate) -> adapt obj to given protocol. Non-standard."
#endif /* !defined(PSYCOPG_MICROPROTOCOLS_H) */
pysqlite_BaseTypeAdapted = 1;
}
- rc = microprotocols_add(type, (PyObject*)&pysqlite_PrepareProtocolType, caster);
+ rc = pysqlite_microprotocols_add(type, (PyObject*)&pysqlite_PrepareProtocolType, caster);
if (rc == -1)
return NULL;
METH_VARARGS, module_register_adapter_doc},
{"register_converter", (PyCFunction)module_register_converter,
METH_VARARGS, module_register_converter_doc},
- {"adapt", (PyCFunction)psyco_microprotocols_adapt, METH_VARARGS,
- psyco_microprotocols_adapt_doc},
+ {"adapt", (PyCFunction)pysqlite_adapt, METH_VARARGS,
+ pysqlite_adapt_doc},
{"enable_callback_tracebacks", (PyCFunction)enable_callback_tracebacks,
METH_VARARGS, enable_callback_tracebacks_doc},
{NULL, NULL}
Py_DECREF(tmp_obj);
/* initialize microprotocols layer */
- microprotocols_init(dict);
+ pysqlite_microprotocols_init(dict);
/* initialize the default converters */
converters_init(dict);
Py_INCREF(sql);
self->sql = sql;
+ Py_BEGIN_ALLOW_THREADS
rc = sqlite3_prepare(connection->db,
sql_cstr,
-1,
&self->st,
&tail);
+ Py_END_ALLOW_THREADS
self->db = connection->db;
if (!_need_adapt(current_param)) {
adapted = current_param;
} else {
- adapted = microprotocols_adapt(current_param, (PyObject*)&pysqlite_PrepareProtocolType, NULL);
+ adapted = pysqlite_microprotocols_adapt(current_param, (PyObject*)&pysqlite_PrepareProtocolType, NULL);
if (adapted) {
Py_DECREF(current_param);
} else {
if (!_need_adapt(current_param)) {
adapted = current_param;
} else {
- adapted = microprotocols_adapt(current_param, (PyObject*)&pysqlite_PrepareProtocolType, NULL);
+ adapted = pysqlite_microprotocols_adapt(current_param, (PyObject*)&pysqlite_PrepareProtocolType, NULL);
if (adapted) {
Py_DECREF(current_param);
} else {
return rc;
}
+ Py_BEGIN_ALLOW_THREADS
rc = sqlite3_prepare(self->db,
sql_cstr,
-1,
&new_st,
&tail);
+ Py_END_ALLOW_THREADS
if (rc == SQLITE_OK) {
/* The efficient sqlite3_transfer_bindings is only available in SQLite
#include "module.h"
#include "connection.h"
-int _sqlite_step_with_busyhandler(sqlite3_stmt* statement, pysqlite_Connection* connection)
+int pysqlite_step(sqlite3_stmt* statement, pysqlite_Connection* connection)
{
int rc;
#include "sqlite3.h"
#include "connection.h"
-int _sqlite_step_with_busyhandler(sqlite3_stmt* statement, pysqlite_Connection* connection);
+int pysqlite_step(sqlite3_stmt* statement, pysqlite_Connection* connection);
/**
* Checks the SQLite error code and sets the appropriate DB-API exception.
projects / python / commitdiff