code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
# First check if gzipping is allowed by the global setting
if not getattr(settings, 'BAKERY_GZIP', False):
return False
# Then check if the content type of this particular file is gzippable
whitelist = getattr(
settings,
'GZIP_CONTENT_TYPES',
... | def is_gzippable(self, path) | Returns a boolean indicating if the provided file path is a candidate
for gzipping. | 4.533026 | 4.350202 | 1.042026 |
logger.debug("Gzipping to {}{}".format(self.fs_name, target_path))
# Write GZIP data to an in-memory buffer
data_buffer = six.BytesIO()
kwargs = dict(
filename=path.basename(target_path),
mode='wb',
fileobj=data_buffer
)
if fl... | def gzip_file(self, target_path, html) | Zips up the provided HTML as a companion for the provided path.
Intended to take advantage of the peculiarities of
Amazon S3's GZIP service.
mtime, an option that writes a timestamp to the output file
is set to 0, to avoid having s3cmd do unnecessary uploads because
of differen... | 3.532718 | 3.466937 | 1.018974 |
if self.url:
url = self.url % kwargs
elif self.pattern_name:
try:
url = reverse(self.pattern_name, args=args, kwargs=kwargs)
except NoReverseMatch:
return None
else:
return None
return url | def get_redirect_url(self, *args, **kwargs) | Return the URL redirect to. Keyword arguments from the
URL pattern match generating the redirect request
are provided as kwargs to this method. | 2.385841 | 2.25999 | 1.055687 |
for detail_view in self.detail_views:
view = self._get_view(detail_view)
view().build_object(self)
self._build_extra()
self._build_related() | def build(self) | Iterates through the views pointed to by self.detail_views, runs
build_object with `self`, and calls _build_extra()
and _build_related(). | 6.660937 | 2.546853 | 2.61536 |
for detail_view in self.detail_views:
view = self._get_view(detail_view)
view().unbuild_object(self)
self._unbuild_extra()
# _build_related again to kill the object from RSS etc.
self._build_related() | def unbuild(self) | Iterates through the views pointed to by self.detail_views, runs
unbuild_object with `self`, and calls _build_extra()
and _build_related(). | 10.804381 | 5.638133 | 1.916305 |
from bakery import tasks
from django.contrib.contenttypes.models import ContentType
# if obj.save(publish=False) has been passed, we skip everything.
if not kwargs.pop('publish', True):
super(AutoPublishingBuildableModel, self).save(*args, **kwargs)
# Otherwi... | def save(self, *args, **kwargs) | A custom save that publishes or unpublishes the object where
appropriate.
Save with keyword argument obj.save(publish=False) to skip the process. | 3.698284 | 3.513919 | 1.052467 |
from bakery import tasks
from django.contrib.contenttypes.models import ContentType
# if obj.save(unpublish=False) has been passed, we skip the task.
unpublish = kwargs.pop('unpublish', True)
# Delete it from the database
super(AutoPublishingBuildableModel, self)... | def delete(self, *args, **kwargs) | Triggers a task that will unpublish the object after it is deleted.
Save with keyword argument obj.delete(unpublish=False) to skip it. | 4.670563 | 3.499438 | 1.334661 |
logger.info("Build started")
# Set options
self.set_options(*args, **options)
# Get the build directory ready
if not options.get("keep_build_dir"):
self.init_build_dir()
# Build up static files
if not options.get("skip_static"):
... | def handle(self, *args, **options) | Making it happen. | 3.724975 | 3.591064 | 1.03729 |
self.verbosity = int(options.get('verbosity', 1))
# Figure out what build directory to use
if options.get("build_dir"):
self.build_dir = options.get("build_dir")
settings.BUILD_DIR = self.build_dir
else:
if not hasattr(settings, 'BUILD_DIR'):... | def set_options(self, *args, **options) | Configure a few global options before things get going. | 2.911044 | 2.864971 | 1.016082 |
# Destroy the build directory, if it exists
logger.debug("Initializing %s" % self.build_dir)
if self.verbosity > 1:
self.stdout.write("Initializing build directory")
if self.fs.exists(self.build_dir):
self.fs.removetree(self.build_dir)
# Then recr... | def init_build_dir(self) | Clear out the build directory and create a new one. | 3.445897 | 3.350342 | 1.028521 |
logger.debug("Building static directory")
if self.verbosity > 1:
self.stdout.write("Building static directory")
management.call_command(
"collectstatic",
interactive=False,
verbosity=0
)
# Set the target directory inside t... | def build_static(self, *args, **options) | Builds the static files directory as well as robots.txt and favicon.ico | 2.732702 | 2.658718 | 1.027827 |
logger.debug("Building media directory")
if self.verbosity > 1:
self.stdout.write("Building media directory")
if os.path.exists(self.media_root) and settings.MEDIA_URL:
target_dir = path.join(self.fs_name, self.build_dir, settings.MEDIA_URL.lstrip('/'))
... | def build_media(self) | Build the media files. | 4.638543 | 4.472936 | 1.037024 |
# Then loop through and run them all
for view_str in self.view_list:
logger.debug("Building %s" % view_str)
if self.verbosity > 1:
self.stdout.write("Building %s" % view_str)
view = get_callable(view_str)
self.get_view_instance(vie... | def build_views(self) | Bake out specified buildable views. | 4.375302 | 4.229039 | 1.034585 |
# Figure out what we're building...
build_list = []
# Walk through the source directory...
for (dirpath, dirnames, filenames) in os.walk(source_dir):
for f in filenames:
# Figure out what is going where
source_path = os.path.join(dirpa... | def copytree_and_gzip(self, source_dir, target_dir) | Copies the provided source directory to the provided target directory.
Gzips JavaScript, CSS and HTML and other files along the way. | 2.821781 | 2.911229 | 0.969275 |
# And then where we want to copy it to.
target_dir = path.dirname(target_path)
if not self.fs.exists(target_dir):
try:
self.fs.makedirs(target_dir)
except OSError:
pass
# determine the mimetype of the file
guess = ... | def copyfile_and_gzip(self, source_path, target_path) | Copies the provided file to the provided target directory.
Gzips JavaScript, CSS and HTML and other files along the way. | 2.902219 | 2.950756 | 0.983551 |
# Counts and such we can use to keep tabs on this as they progress
self.uploaded_files = 0
self.uploaded_file_list = []
self.deleted_files = 0
self.deleted_file_list = []
self.start_time = time.time()
# Configure all the options we're going to use
... | def handle(self, *args, **options) | Sync files in the build directory to a specified S3 bucket | 2.93516 | 2.90912 | 1.008951 |
self.verbosity = int(options.get('verbosity'))
# Will we be gzipping?
self.gzip = getattr(settings, 'BAKERY_GZIP', False)
# And if so what content types will we be gzipping?
self.gzip_content_types = getattr(
settings,
'GZIP_CONTENT_TYPES',
... | def set_options(self, options) | Configure all the many options we'll need to make this happen. | 2.77672 | 2.745122 | 1.011511 |
logger.debug("Retrieving bucket object list")
paginator = self.s3_client.get_paginator('list_objects')
options = {
'Bucket': self.aws_bucket_name
}
if self.aws_bucket_prefix:
logger.debug("Adding prefix {} to bucket list as a filter".format(self.... | def get_bucket_file_list(self) | Little utility method that handles pagination and returns
all objects in given bucket. | 2.663989 | 2.545085 | 1.046719 |
file_list = []
for (dirpath, dirnames, filenames) in os.walk(self.build_dir):
for fname in filenames:
# relative path, to sync with the S3 key
local_key = os.path.join(
os.path.relpath(dirpath, self.build_dir),
... | def get_local_file_list(self) | Walk the local build directory and create a list of relative and
absolute paths to files. | 2.632604 | 2.454062 | 1.072754 |
# Create a list to put all the files we're going to update
self.update_list = []
# Figure out which files need to be updated and upload all these files
logger.debug("Comparing {} local files with {} bucket files".format(
len(self.local_file_list),
len(se... | def sync_with_s3(self) | Walk through our self.local_files list, and match them with the list
of keys in the S3 bucket. | 2.679834 | 2.672928 | 1.002584 |
with open(filename, 'rb') as f:
m = hashlib.md5(f.read())
return m.hexdigest() | def get_md5(self, filename) | Returns the md5 checksum of the provided file name. | 2.253101 | 2.193779 | 1.027041 |
# Loop through the file contents ...
md5s = []
with open(filename, 'rb') as fp:
while True:
# Break it into chunks
data = fp.read(chunk_size)
# Finish when there are no more
if not data:
brea... | def get_multipart_md5(self, filename, chunk_size=8 * 1024 * 1024) | Returns the md5 checksum of the provided file name after breaking it into chunks.
This is done to mirror the method used by Amazon S3 after a multipart upload. | 4.034317 | 3.915908 | 1.030238 |
# Where is the file?
file_path = os.path.join(self.build_dir, file_key)
# If we're in force_publish mode just add it
if self.force_publish:
self.update_list.append((file_key, file_path))
# And quit now
return
# Does it exist in our s... | def compare_local_file(self, file_key) | Compares a local version of a file with what's already published.
If an update is needed, the file's key is added self.update_list. | 3.545638 | 3.406978 | 1.040699 |
extra_args = {'ACL': self.acl}
# determine the mimetype of the file
guess = mimetypes.guess_type(filename)
content_type = guess[0]
encoding = guess[1]
if content_type:
extra_args['ContentType'] = content_type
# add the gzip headers, if neces... | def upload_to_s3(self, key, filename) | Set the content type and gzip headers if applicable
and upload the item to S3 | 2.709645 | 2.642754 | 1.025311 |
try:
attr = getattr(self, attname)
except AttributeError:
return default
if callable(attr) or args:
args = args[:] if args else []
# Check co_argcount rather than try/excepting the function and
# catching the TypeError, becau... | def _get_bakery_dynamic_attr(self, attname, obj, args=None, default=None) | Allows subclasses to provide an attribute (say, 'foo') in three
different ways: As a fixed class-level property or as a method
foo(self) or foo(self, obj). The second argument argument 'obj' is
the "subject" of the current Feed invocation. See the Django Feed
documentation for details.
... | 4.334276 | 4.413666 | 0.982013 |
year = super(BuildableYearArchiveView, self).get_year()
fmt = self.get_year_format()
return date(int(year), 1, 1).strftime(fmt) | def get_year(self) | Return the year from the database in the format expected by the URL. | 5.569639 | 4.581638 | 1.215643 |
self.year = str(dt.year)
logger.debug("Building %s" % self.year)
self.request = self.create_request(self.get_url())
target_path = self.get_build_path()
self.build_file(target_path, self.get_content()) | def build_year(self, dt) | Build the page for the provided year. | 4.42801 | 3.762913 | 1.176751 |
qs = self.get_dated_queryset()
years = self.get_date_list(qs)
[self.build_year(dt) for dt in years] | def build_dated_queryset(self) | Build pages for all years in the queryset. | 6.491217 | 4.687826 | 1.384697 |
year = super(BuildableMonthArchiveView, self).get_year()
month = super(BuildableMonthArchiveView, self).get_month()
fmt = self.get_month_format()
return date(int(year), int(month), 1).strftime(fmt) | def get_month(self) | Return the month from the database in the format expected by the URL. | 3.436751 | 2.993573 | 1.148043 |
qs = self.get_dated_queryset()
months = self.get_date_list(qs)
[self.build_month(dt) for dt in months] | def build_dated_queryset(self) | Build pages for all years in the queryset. | 6.790594 | 5.256399 | 1.291872 |
self.year = str(dt.year)
self.month = str(dt.month)
logger.debug("Building %s-%s" % (self.year, self.month))
target_path = os.path.split(self.get_build_path())[0]
if self.fs.exists(target_path):
logger.debug("Removing {}".format(target_path))
self... | def unbuild_month(self, dt) | Deletes the directory at self.get_build_path. | 2.898975 | 2.461246 | 1.177848 |
year = super(BuildableDayArchiveView, self).get_year()
fmt = self.get_year_format()
dt = date(int(year), 1, 1)
return dt.strftime(fmt) | def get_year(self) | Return the year from the database in the format expected by the URL. | 5.710858 | 4.551948 | 1.254597 |
year = super(BuildableDayArchiveView, self).get_year()
month = super(BuildableDayArchiveView, self).get_month()
fmt = self.get_month_format()
dt = date(int(year), int(month), 1)
return dt.strftime(fmt) | def get_month(self) | Return the month from the database in the format expected by the URL. | 3.61426 | 3.113543 | 1.160819 |
year = super(BuildableDayArchiveView, self).get_year()
month = super(BuildableDayArchiveView, self).get_month()
day = super(BuildableDayArchiveView, self).get_day()
fmt = self.get_day_format()
dt = date(int(year), int(month), int(day))
return dt.strftime(fmt) | def get_day(self) | Return the day from the database in the format expected by the URL. | 2.811006 | 2.513987 | 1.118147 |
return os.path.join(
'/archive',
self.get_year(),
self.get_month(),
self.get_day()
) | def get_url(self) | The URL at which the detail page should appear.
By default it is /archive/ + the year in self.year_format + the
month in self.month_format + the day in the self.day_format.
An example would be /archive/2016/01/01/. | 4.499724 | 3.430537 | 1.311668 |
target_path = path.join(settings.BUILD_DIR, self.get_url().lstrip('/'))
if not self.fs.exists(target_path):
logger.debug("Creating {}".format(target_path))
self.fs.makedirs(target_path)
return os.path.join(target_path, 'index.html') | def get_build_path(self) | Used to determine where to build the page. Override this if you
would like your page at a different location. By default it
will be built at self.get_url() + "/index.html" | 3.223191 | 2.583098 | 1.2478 |
self.month = str(dt.month)
self.year = str(dt.year)
self.day = str(dt.day)
logger.debug("Building %s-%s-%s" % (self.year, self.month, self.day))
self.request = self.create_request(self.get_url())
path = self.get_build_path()
self.build_file(path, self.get... | def build_day(self, dt) | Build the page for the provided day. | 2.998078 | 2.663666 | 1.125546 |
qs = self.get_dated_queryset()
days = self.get_date_list(qs, date_type='day')
[self.build_day(dt) for dt in days] | def build_dated_queryset(self) | Build pages for all years in the queryset. | 6.537938 | 5.077915 | 1.287524 |
session_kwargs = {}
if hasattr(settings, 'AWS_ACCESS_KEY_ID'):
session_kwargs['aws_access_key_id'] = settings.AWS_ACCESS_KEY_ID
if hasattr(settings, 'AWS_SECRET_ACCESS_KEY'):
session_kwargs['aws_secret_access_key'] = settings.AWS_SECRET_ACCESS_KEY
boto3.setup_default_session(**sess... | def get_s3_client() | A DRY place to make sure AWS credentials in settings override
environment based credentials. Boto3 will fall back to:
http://boto3.readthedocs.io/en/latest/guide/configuration.html | 1.548764 | 1.516829 | 1.021054 |
key_list = page.get('Contents', [])
logger.debug("Retrieving page with {} keys".format(
len(key_list),
))
return dict((k.get('Key'), k) for k in key_list) | def get_bucket_page(page) | Returns all the keys in a s3 bucket paginator page. | 4.393278 | 4.035185 | 1.088743 |
logger.debug("Retrieving bucket object list")
if not s3_client:
s3_client, s3_resource = get_s3_client()
obj_dict = {}
paginator = s3_client.get_paginator('list_objects')
page_iterator = paginator.paginate(Bucket=aws_bucket_name)
for page in page_iterator:
key_list = page.... | def get_all_objects_in_bucket(
aws_bucket_name,
s3_client=None,
max_keys=1000
) | Little utility method that handles pagination and returns
all objects in given bucket. | 2.134431 | 2.140934 | 0.996963 |
if s3_client is None:
s3_client, s3_resource = get_s3_client()
key_chunks = []
for i in range(0, len(keys), chunk_size):
chunk = []
for key in (list(keys)[i:i+100]):
chunk.append({'Key': key})
key_chunks.append(chunk)
for chunk in key_chunks:
s3_... | def batch_delete_s3_objects(
keys,
aws_bucket_name,
chunk_size=100,
s3_client=None
) | Utility method that batch deletes objects in given bucket. | 2.100204 | 2.102268 | 0.999018 |
if isinstance(p, str):
p = string(p)
return regex(r'\s*') >> p << regex(r'\s*') | def lexeme(p) | From a parser (or string), make a parser that consumes
whitespace on either side. | 5.255884 | 4.095832 | 1.283227 |
return lexeme(p).optional().map(lambda v: False if v is None else True) | def is_present(p) | Given a parser or string, make a parser that returns
True if the parser matches, False otherwise | 13.77759 | 14.270865 | 0.965435 |
(result, _) = (self << eof).parse_partial(stream)
return result | def parse(self, stream) | Parse a string or list of tokens and return the result or raise a ParseError. | 31.281385 | 20.271044 | 1.543156 |
result = self(stream, 0)
if result.status:
return (result.value, stream[result.index:])
else:
raise ParseError(result.expected, stream, result.furthest) | def parse_partial(self, stream) | Parse the longest possible prefix of a given string.
Return a tuple of the result and the rest of the string,
or raise a ParseError. | 6.23097 | 4.684433 | 1.330144 |
items_sep, fields_sep, keys_sep = separators
return items_sep.join(fields_sep.join(keys_sep.join(x) for x in sorted(it.items()))
for it in array_value) | def extract_key_values(array_value, separators=(';', ',', ':'), **kwargs) | Serialize array of objects with simple key-values | 4.587841 | 4.205057 | 1.091029 |
with open(schemafile) as f:
return cls(json.load(f)) | def from_schemafile(cls, schemafile) | Create a Flatson instance from a schemafile | 3.612632 | 3.453533 | 1.046069 |
if name in self._default_serialization_methods:
raise ValueError("Can't replace original %s serialization method")
self._serialization_methods[name] = serialize_func | def register_serialization_method(self, name, serialize_func) | Register a custom serialization method that can be
used via schema configuration | 4.583811 | 5.113591 | 0.896398 |
return [self._serialize(f, obj) for f in self.fields] | def flatten(self, obj) | Return a list with the field values | 7.083009 | 5.452821 | 1.298962 |
return OrderedDict(zip(self.fieldnames, self.flatten(obj))) | def flatten_dict(self, obj) | Return an OrderedDict dict preserving order of keys in fieldnames | 8.879423 | 4.413944 | 2.011675 |
LOGGER.debug('Connection %s closing', self.id)
if self.busy:
raise ConnectionBusyError(self)
with self._lock:
if not self.handle.closed:
try:
self.handle.close()
except psycopg2.InterfaceError as error:
... | def close(self) | Close the connection
:raises: ConnectionBusyError | 4.308752 | 3.749168 | 1.149255 |
if self.handle.isexecuting():
return True
elif self.used_by is None:
return False
return not self.used_by() is None | def busy(self) | Return if the connection is currently executing a query or is locked
by a session that still exists.
:rtype: bool | 7.951653 | 7.770044 | 1.023373 |
LOGGER.debug('Connection %s freeing', self.id)
if self.handle.isexecuting():
raise ConnectionBusyError(self)
with self._lock:
self.used_by = None
LOGGER.debug('Connection %s freed', self.id) | def free(self) | Remove the lock on the connection if the connection is not active
:raises: ConnectionBusyError | 6.246918 | 4.950298 | 1.261928 |
if self.busy:
raise ConnectionBusyError(self)
with self._lock:
self.used_by = weakref.ref(session)
LOGGER.debug('Connection %s locked', self.id) | def lock(self, session) | Lock the connection, ensuring that it is not busy and storing
a weakref for the session.
:param queries.Session session: The session to lock the connection with
:raises: ConnectionBusyError | 6.705616 | 5.364222 | 1.250063 |
if id(connection) in self.connections:
raise ValueError('Connection already exists in pool')
if len(self.connections) == self.max_size:
LOGGER.warning('Race condition found when adding new connection')
try:
connection.close()
exce... | def add(self, connection) | Add a new connection to the pool
:param connection: The connection to add to the pool
:type connection: psycopg2.extensions.connection
:raises: PoolFullError | 4.01137 | 4.001751 | 1.002404 |
return [c for c in self.connections.values()
if c.busy and not c.closed] | def busy_connections(self) | Return a list of active/busy connections
:rtype: list | 4.929905 | 5.680995 | 0.867789 |
LOGGER.debug('Cleaning the pool')
for connection in [self.connections[k] for k in self.connections if
self.connections[k].closed]:
LOGGER.debug('Removing %s', connection.id)
self.remove(connection.handle)
if self.idle_duration > self.i... | def clean(self) | Clean the pool by removing any closed connections and if the pool's
idle has exceeded its idle TTL, remove all connections. | 5.151305 | 3.736154 | 1.378772 |
for cid in list(self.connections.keys()):
self.remove(self.connections[cid].handle)
LOGGER.debug('Pool %s closed', self.id) | def close(self) | Close the pool by closing and removing all of the connections | 8.066469 | 5.722838 | 1.409523 |
LOGGER.debug('Pool %s freeing connection %s', self.id, id(connection))
try:
self.connection_handle(connection).free()
except KeyError:
raise ConnectionNotFoundError(self.id, id(connection))
if self.idle_connections == list(self.connections.values()):
... | def free(self, connection) | Free the connection from use by the session that was using it.
:param connection: The connection to free
:type connection: psycopg2.extensions.connection
:raises: ConnectionNotFoundError | 4.480501 | 4.201571 | 1.066387 |
idle = self.idle_connections
if idle:
connection = idle.pop(0)
connection.lock(session)
if self.idle_start:
with self._lock:
self.idle_start = None
return connection.handle
raise NoIdleConnectionsError(s... | def get(self, session) | Return an idle connection and assign the session to the connection
:param queries.Session session: The session to assign
:rtype: psycopg2.extensions.connection
:raises: NoIdleConnectionsError | 6.700688 | 5.512594 | 1.215524 |
return [c for c in self.connections.values()
if not c.busy and not c.closed] | def idle_connections(self) | Return a list of idle connections
:rtype: list | 5.079988 | 5.847279 | 0.868778 |
cid = id(connection)
try:
self.connection_handle(connection).lock(session)
except KeyError:
raise ConnectionNotFoundError(self.id, cid)
else:
if self.idle_start:
with self._lock:
self.idle_start = None
... | def lock(self, connection, session) | Explicitly lock the specified connection
:type connection: psycopg2.extensions.connection
:param connection: The connection to lock
:param queries.Session session: The session to hold the lock | 5.750189 | 6.523287 | 0.881486 |
cid = id(connection)
if cid not in self.connections:
raise ConnectionNotFoundError(self.id, cid)
self.connection_handle(connection).close()
with self._lock:
del self.connections[cid]
LOGGER.debug('Pool %s removed connection %s', self.id, cid) | def remove(self, connection) | Remove the connection from the pool
:param connection: The connection to remove
:type connection: psycopg2.extensions.connection
:raises: ConnectionNotFoundError
:raises: ConnectionBusyError | 4.558841 | 4.086958 | 1.115461 |
return {
'connections': {
'busy': len(self.busy_connections),
'closed': len(self.closed_connections),
'executing': len(self.executing_connections),
'idle': len(self.idle_connections),
'locked': len(self.busy_con... | def report(self) | Return a report about the pool state and configuration.
:rtype: dict | 2.932977 | 2.734581 | 1.07255 |
with self._lock:
for cid in list(self.connections.keys()):
if self.connections[cid].executing:
raise ConnectionBusyError(cid)
if self.connections[cid].locked:
self.connections[cid].free()
self.connection... | def shutdown(self) | Forcefully shutdown the entire pool, closing all non-executing
connections.
:raises: ConnectionBusyError | 3.865802 | 3.085761 | 1.252787 |
with cls._lock:
cls._ensure_pool_exists(pid)
cls._pools[pid].add(connection) | def add(cls, pid, connection) | Add a new connection and session to a pool.
:param str pid: The pool id
:type connection: psycopg2.extensions.connection
:param connection: The connection to add to the pool | 5.563025 | 6.372959 | 0.872911 |
with cls._lock:
try:
cls._ensure_pool_exists(pid)
except KeyError:
LOGGER.debug('Pool clean invoked against missing pool %s', pid)
return
cls._pools[pid].clean()
cls._maybe_remove_pool(pid) | def clean(cls, pid) | Clean the specified pool, removing any closed connections or
stale locks.
:param str pid: The pool id to clean | 5.338863 | 5.922016 | 0.901528 |
if pid in cls._pools:
raise KeyError('Pool %s already exists' % pid)
with cls._lock:
LOGGER.debug("Creating Pool: %s (%i/%i)", pid, idle_ttl, max_size)
cls._pools[pid] = Pool(pid, idle_ttl, max_size, time_method) | def create(cls, pid, idle_ttl=DEFAULT_IDLE_TTL, max_size=DEFAULT_MAX_SIZE,
time_method=None) | Create a new pool, with the ability to pass in values to override
the default idle TTL and the default maximum size.
A pool's idle TTL defines the amount of time that a pool can be open
without any sessions before it is removed.
A pool's max size defines the maximum number of connectio... | 2.900817 | 3.156017 | 0.919138 |
with cls._lock:
LOGGER.debug('Freeing %s from pool %s', id(connection), pid)
cls._ensure_pool_exists(pid)
cls._pools[pid].free(connection) | def free(cls, pid, connection) | Free a connection that was locked by a session
:param str pid: The pool ID
:param connection: The connection to remove
:type connection: psycopg2.extensions.connection | 5.112678 | 5.155088 | 0.991773 |
with cls._lock:
cls._ensure_pool_exists(pid)
return cls._pools[pid].get(session) | def get(cls, pid, session) | Get an idle, unused connection from the pool. Once a connection has
been retrieved, it will be marked as in-use until it is freed.
:param str pid: The pool ID
:param queries.Session session: The session to assign to the connection
:rtype: psycopg2.extensions.connection | 5.511879 | 7.309681 | 0.754052 |
with cls._lock:
return cls._pools[pid].connection_handle(connection) | def get_connection(cls, pid, connection) | Return the specified :class:`~queries.pool.Connection` from the
pool.
:param str pid: The pool ID
:param connection: The connection to return for
:type connection: psycopg2.extensions.connection
:rtype: queries.pool.Connection | 11.869633 | 16.281431 | 0.729029 |
with cls._lock:
cls._ensure_pool_exists(pid)
return connection in cls._pools[pid] | def has_connection(cls, pid, connection) | Check to see if a pool has the specified connection
:param str pid: The pool ID
:param connection: The connection to check for
:type connection: psycopg2.extensions.connection
:rtype: bool | 6.414604 | 7.117787 | 0.901208 |
with cls._lock:
cls._ensure_pool_exists(pid)
return bool(cls._pools[pid].idle_connections) | def has_idle_connection(cls, pid) | Check to see if a pool has an idle connection
:param str pid: The pool ID
:rtype: bool | 5.979589 | 6.410991 | 0.932709 |
with cls._lock:
cls._ensure_pool_exists(pid)
return cls._pools[pid].is_full | def is_full(cls, pid) | Return a bool indicating if the specified pool is full
:param str pid: The pool id
:rtype: bool | 5.664246 | 5.839606 | 0.96997 |
with cls._lock:
cls._ensure_pool_exists(pid)
cls._pools[pid].lock(connection, session) | def lock(cls, pid, connection, session) | Explicitly lock the specified connection in the pool
:param str pid: The pool id
:type connection: psycopg2.extensions.connection
:param connection: The connection to add to the pool
:param queries.Session session: The session to hold the lock | 5.319861 | 8.255533 | 0.644399 |
with cls._lock:
cls._ensure_pool_exists(pid)
cls._pools[pid].close()
del cls._pools[pid] | def remove(cls, pid) | Remove a pool, closing all connections
:param str pid: The pool ID | 4.157514 | 4.755346 | 0.874282 |
cls._ensure_pool_exists(pid)
cls._pools[pid].remove(connection) | def remove_connection(cls, pid, connection) | Remove a connection from the pool, closing it if is open.
:param str pid: The pool ID
:param connection: The connection to remove
:type connection: psycopg2.extensions.connection
:raises: ConnectionNotFoundError | 6.788774 | 6.873895 | 0.987617 |
with cls._lock:
cls._ensure_pool_exists(pid)
cls._pools[pid].set_idle_ttl(ttl) | def set_idle_ttl(cls, pid, ttl) | Set the idle TTL for a pool, after which it will be destroyed.
:param str pid: The pool id
:param int ttl: The TTL for an idle pool | 4.12344 | 5.411238 | 0.762014 |
with cls._lock:
cls._ensure_pool_exists(pid)
cls._pools[pid].set_max_size(size) | def set_max_size(cls, pid, size) | Set the maximum number of connections for the specified pool
:param str pid: The pool to set the size for
:param int size: The maximum number of connections | 4.33354 | 6.610533 | 0.655551 |
for pid in list(cls._pools.keys()):
cls._pools[pid].shutdown()
LOGGER.info('Shutdown complete, all pooled connections closed') | def shutdown(cls) | Close all connections on in all pools | 9.21684 | 6.086092 | 1.51441 |
with cls._lock:
cls._ensure_pool_exists(pid)
return len(cls._pools[pid]) | def size(cls, pid) | Return the number of connections in the pool
:param str pid: The pool id
:rtype int | 5.461527 | 5.971561 | 0.914589 |
return {
'timestamp': datetime.datetime.utcnow().isoformat(),
'process': os.getpid(),
'pools': dict([(i, p.report()) for i, p in cls._pools.items()])
} | def report(cls) | Return the state of the all of the registered pools.
:rtype: dict | 4.593814 | 3.668878 | 1.252103 |
if not len(cls._pools[pid]):
del cls._pools[pid] | def _maybe_remove_pool(cls, pid) | If the pool has no open connections, remove it
:param str pid: The pool id to clean | 5.482966 | 8.059567 | 0.680305 |
try:
self._cursor.callproc(name, args)
except psycopg2.Error as err:
self._incr_exceptions()
raise err
finally:
self._incr_executions()
return results.Results(self._cursor) | def callproc(self, name, args=None) | Call a stored procedure on the server, returning the results in a
:py:class:`queries.Results` instance.
:param str name: The procedure name
:param list args: The list of arguments to pass in
:rtype: queries.Results
:raises: queries.DataError
:raises: queries.DatabaseErro... | 4.958943 | 5.029267 | 0.986017 |
if not self._conn:
raise psycopg2.InterfaceError('Connection not open')
LOGGER.info('Closing connection %r in %s', self._conn, self.pid)
self._pool_manager.free(self.pid, self._conn)
self._pool_manager.remove_connection(self.pid, self._conn)
# Un-assign the ... | def close(self) | Explicitly close the connection and remove it from the connection
pool if pooling is enabled. If the connection is already closed
:raises: psycopg2.InterfaceError | 4.583012 | 3.975775 | 1.152734 |
return hashlib.md5(':'.join([self.__class__.__name__,
self._uri]).encode('utf-8')).hexdigest() | def pid(self) | Return the pool ID used for connection pooling.
:rtype: str | 7.41974 | 7.860576 | 0.943918 |
try:
self._cursor.execute(sql, parameters)
except psycopg2.Error as err:
self._incr_exceptions()
raise err
finally:
self._incr_executions()
return results.Results(self._cursor) | def query(self, sql, parameters=None) | A generator to issue a query on the server, mogrifying the
parameters against the sql statement. Results are returned as a
:py:class:`queries.Results` object which can act as an iterator and
has multiple ways to access the result data.
:param str sql: The SQL statement
:param di... | 4.650568 | 4.925261 | 0.944228 |
if self._conn.encoding != value:
self._conn.set_client_encoding(value) | def set_encoding(self, value=DEFAULT_ENCODING) | Set the client encoding for the session if the value specified
is different than the current client encoding.
:param str value: The encoding value to use | 5.017162 | 6.387079 | 0.785518 |
if self._cursor:
LOGGER.debug('Closing the cursor on %s', self.pid)
self._cursor.close()
self._cursor = None
if self._conn:
LOGGER.debug('Freeing %s in the pool', self.pid)
try:
pool.PoolManager.instance().free(self.pi... | def _cleanup(self) | Remove the connection from the stack, closing out the cursor | 4.16141 | 3.578808 | 1.162792 |
# Attempt to get a cached connection from the connection pool
try:
connection = self._pool_manager.get(self.pid, self)
LOGGER.debug("Re-using connection for %s", self.pid)
except pool.NoIdleConnectionsError:
if self._pool_manager.is_full(self.pid):
... | def _connect(self) | Connect to PostgreSQL, either by reusing a connection from the pool
if possible, or by creating the new connection.
:rtype: psycopg2.extensions.connection
:raises: pool.NoIdleConnectionsError | 6.395816 | 5.738999 | 1.114448 |
cursor = connection.cursor(name=name,
cursor_factory=self._cursor_factory)
if name is not None:
cursor.scrollable = True
cursor.withhold = True
return cursor | def _get_cursor(self, connection, name=None) | Return a cursor for the given cursor_factory. Specify a name to
use server-side cursors.
:param connection: The connection to create a cursor on
:type connection: psycopg2.extensions.connection
:param str name: A cursor name for a server side cursor
:rtype: psycopg2.extensions.c... | 4.010459 | 4.650095 | 0.862447 |
self._pool_manager.get_connection(self.pid, self._conn).exceptions += 1 | def _incr_exceptions(self) | Increment the number of exceptions for the current connection. | 16.788525 | 10.289918 | 1.631551 |
self._pool_manager.get_connection(self.pid, self._conn).executions += 1 | def _incr_executions(self) | Increment the number of executions for the current connection. | 18.4039 | 10.162116 | 1.81103 |
psycopg2.extensions.register_type(psycopg2.extensions.UNICODE,
connection)
psycopg2.extensions.register_type(psycopg2.extensions.UNICODEARRAY,
connection) | def _register_unicode(connection) | Register the cursor to be able to receive Unicode string.
:type connection: psycopg2.extensions.connection
:param connection: Where to register things | 2.01908 | 2.349557 | 0.859345 |
if self._conn.status == psycopg2.extensions.STATUS_BEGIN:
return self.READY
return self._conn.status | def _status(self) | Return the current connection status as an integer value.
The status should match one of the following constants:
- queries.Session.INTRANS: Connection established, in transaction
- queries.Session.PREPARED: Prepared for second phase of transaction
- queries.Session.READY: Connected, n... | 7.788153 | 6.305507 | 1.235135 |
if not self.cursor.rowcount:
return {}
self._rewind()
if self.cursor.rowcount == 1:
return dict(self.cursor.fetchone())
else:
raise ValueError('More than one row') | def as_dict(self) | Return a single row result as a dictionary. If the results contain
multiple rows, a :py:class:`ValueError` will be raised.
:return: dict
:raises: ValueError | 4.633496 | 4.008274 | 1.155983 |
if not self.cursor.rowcount:
return []
self.cursor.scroll(0, 'absolute')
return self.cursor.fetchall() | def items(self) | Return all of the rows that are in the result set.
:rtype: list | 4.90019 | 4.43229 | 1.105566 |
if pwd is None:
return getpass.getuser()
else:
try:
return pwd.getpwuid(os.getuid())[0]
except KeyError as error:
LOGGER.error('Could not get logged-in user: %s', error) | def get_current_user() | Return the current username for the logged in user
:rtype: str | 3.639249 | 3.658193 | 0.994821 |
if port:
host = '%s:%s' % (host, port)
if password:
return 'postgresql://%s:%s@%s/%s' % (user, password, host, dbname)
return 'postgresql://%s@%s/%s' % (user, host, dbname) | def uri(host='localhost', port=5432, dbname='postgres', user='postgres',
password=None) | Return a PostgreSQL connection URI for the specified values.
:param str host: Host to connect to
:param int port: Port to connect on
:param str dbname: The database name
:param str user: User to connect as
:param str password: The password to use, None for no password
:return str: The PostgreSQ... | 1.733076 | 2.025685 | 0.855551 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.