Search is not available for this dataset
text stringlengths 75 104k |
|---|
def async_refresh(self, *args, **kwargs):
"""
Trigger an asynchronous job to refresh the cache
"""
# We trigger the task with the class path to import as well as the
# (a) args and kwargs for instantiating the class
# (b) args and kwargs for calling the 'refresh' method
... |
def should_stale_item_be_fetched_synchronously(self, delta, *args, **kwargs):
"""
Return whether to refresh an item synchronously when it is found in the
cache but stale
"""
if self.fetch_on_stale_threshold is None:
return False
return delta > (self.fetch_on_s... |
def key(self, *args, **kwargs):
"""
Return the cache key to use.
If you're passing anything but primitive types to the ``get`` method,
it's likely that you'll need to override this method.
"""
if not args and not kwargs:
return self.class_path
try:
... |
def hash(self, value):
"""
Generate a hash of the given iterable.
This is for use in a cache key.
"""
if is_iterable(value):
value = tuple(to_bytestring(v) for v in value)
return hashlib.md5(six.b(':').join(value)).hexdigest() |
def perform_async_refresh(cls, klass_str, obj_args, obj_kwargs, call_args, call_kwargs):
"""
Re-populate cache using the given job class.
The job class is instantiated with the passed constructor args and the
refresh method is called with the passed call args. That is::
da... |
def cacheback(lifetime=None, fetch_on_miss=None, cache_alias=None,
job_class=None, task_options=None, **job_class_kwargs):
"""
Decorate function to cache its return value.
:lifetime: How long to cache items for
:fetch_on_miss: Whether to perform a synchronous fetch when no cached
... |
def angle(v1, v2):
"""Return the angle in radians between vectors 'v1' and 'v2'."""
v1_u = unit_vector(v1)
v2_u = unit_vector(v2)
return np.arccos(np.clip(np.dot(v1_u, v2_u), -1.0, 1.0)) |
def keep_high_angle(vertices, min_angle_deg):
"""Keep vertices with angles higher then given minimum."""
accepted = []
v = vertices
v1 = v[1] - v[0]
accepted.append((v[0][0], v[0][1]))
for i in range(1, len(v) - 2):
v2 = v[i + 1] - v[i - 1]
diff_angle = np.fabs(angle(v1, v2) * 18... |
def set_contourf_properties(stroke_width, fcolor, fill_opacity, contour_levels, contourf_idx, unit):
"""Set property values for Polygon."""
return {
"stroke": fcolor,
"stroke-width": stroke_width,
"stroke-opacity": 1,
"fill": fcolor,
"fill-opacity": fill_opacity,
... |
def contour_to_geojson(contour, geojson_filepath=None, min_angle_deg=None,
ndigits=5, unit='', stroke_width=1, geojson_properties=None, strdump=False,
serialize=True):
"""Transform matplotlib.contour to geojson."""
collections = contour.collections
contour_index... |
def contourf_to_geojson_overlap(contourf, geojson_filepath=None, min_angle_deg=None,
ndigits=5, unit='', stroke_width=1, fill_opacity=.9,
geojson_properties=None, strdump=False, serialize=True):
"""Transform matplotlib.contourf to geojson with overlapp... |
def contourf_to_geojson(contourf, geojson_filepath=None, min_angle_deg=None,
ndigits=5, unit='', stroke_width=1, fill_opacity=.9,
geojson_properties=None, strdump=False, serialize=True):
"""Transform matplotlib.contourf to geojson with MultiPolygons."""
polygon_fe... |
def get_authorize_callback(endpoint, provider_id):
"""Get a qualified URL for the provider to return to upon authorization
param: endpoint: Absolute path to append to the application's host
"""
endpoint_prefix = config_value('BLUEPRINT_NAME')
url = url_for(endpoint_prefix + '.' + endpoint, provider... |
def delete_connection(self, **kwargs):
"""Remove a single connection to a provider for the specified user."""
conn = self.find_connection(**kwargs)
if not conn:
return False
self.delete(conn)
return True |
def delete_connections(self, **kwargs):
"""Remove a single connection to a provider for the specified user."""
rv = False
for c in self.find_connections(**kwargs):
self.delete(c)
rv = True
return rv |
def login(provider_id):
"""Starts the provider login OAuth flow"""
provider = get_provider_or_404(provider_id)
callback_url = get_authorize_callback('login', provider_id)
post_login = request.form.get('next', get_post_login_redirect())
session[config_value('POST_OAUTH_LOGIN_SESSION_KEY')] = post_log... |
def connect(provider_id):
"""Starts the provider connection OAuth flow"""
provider = get_provider_or_404(provider_id)
callback_url = get_authorize_callback('connect', provider_id)
allow_view = get_url(config_value('CONNECT_ALLOW_VIEW'))
pc = request.form.get('next', allow_view)
session[config_va... |
def remove_all_connections(provider_id):
"""Remove all connections for the authenticated user to the
specified provider
"""
provider = get_provider_or_404(provider_id)
ctx = dict(provider=provider.name, user=current_user)
deleted = _datastore.delete_connections(user_id=current_user.get_id(),
... |
def remove_connection(provider_id, provider_user_id):
"""Remove a specific connection for the authenticated user to the
specified provider
"""
provider = get_provider_or_404(provider_id)
ctx = dict(provider=provider.name, user=current_user,
provider_user_id=provider_user_id)
del... |
def connect_handler(cv, provider):
"""Shared method to handle the connection process
:param connection_values: A dictionary containing the connection values
:param provider_id: The provider ID the connection shoudl be made to
"""
cv.setdefault('user_id', current_user.get_id())
connection = _dat... |
def login_handler(response, provider, query):
"""Shared method to handle the signin process"""
connection = _datastore.find_connection(**query)
if connection:
after_this_request(_commit)
token_pair = get_token_pair_from_oauth_response(provider, response)
if (token_pair['access_toke... |
def init_app(self, app, datastore=None):
"""Initialize the application with the Social extension
:param app: The Flask application
:param datastore: Connection datastore instance
"""
datastore = datastore or self.datastore
for key, value in default_config.items():
... |
def guess(filename, fallback='application/octet-stream'):
"""
Using the mimetypes library, guess the mimetype and
encoding for a given *filename*. If the mimetype
cannot be guessed, *fallback* is assumed instead.
:param filename: Filename- can be absolute path.
:param fallback: A fallback mimet... |
def format_addresses(addrs):
"""
Given an iterable of addresses or name-address
tuples *addrs*, return a header value that joins
all of them together with a space and a comma.
"""
return ', '.join(
formataddr(item) if isinstance(item, tuple) else item
for item in addrs
) |
def stringify_address(addr, encoding='utf-8'):
"""
Given an email address *addr*, try to encode
it with ASCII. If it's not possible, encode
the *local-part* with the *encoding* and the
*domain* with IDNA.
The result is a unicode string with the domain
encoded as idna.
"""
if isinsta... |
def email(sender=None, receivers=(), cc=(), bcc=(),
subject=None, content=None, encoding='utf8',
attachments=()):
"""
Creates a Collection object with a HTML *content*,
and *attachments*.
:param content: HTML content.
:param encoding: Encoding of the email.
:param attachment... |
def postman(host, port=587, auth=(None, None),
force_tls=False, options=None):
"""
Creates a Postman object with TLS and Auth
middleware. TLS is placed before authentication
because usually authentication happens and is
accepted only after TLS is enabled.
:param auth: Tuple of (user... |
def mime(self):
"""
Returns the finalised mime object, after
applying the internal headers. Usually this
is not to be overriden.
"""
mime = self.mime_object()
self.headers.prepare(mime)
return mime |
def send(self, envelope):
"""
Send an *envelope* which may be an envelope
or an enclosure-like object, see
:class:`~mailthon.enclosure.Enclosure` and
:class:`~mailthon.envelope.Envelope`, and
returns a :class:`~mailthon.response.SendmailResponse`
object.
"... |
def connection(self):
"""
A context manager that returns a connection
to the server using some *session*.
"""
conn = self.session(**self.options)
try:
for item in self.middlewares:
item(conn)
yield conn
finally:
... |
def sender(self):
"""
Returns the sender, respecting the Resent-*
headers. In any case, prefer Sender over From,
meaning that if Sender is present then From is
ignored, as per the RFC.
"""
to_fetch = (
['Resent-Sender', 'Resent-From'] if self.resent el... |
def receivers(self):
"""
Returns a list of receivers, obtained from the
To, Cc, and Bcc headers, respecting the Resent-*
headers if the email was resent.
"""
attrs = (
['Resent-To', 'Resent-Cc', 'Resent-Bcc'] if self.resent else
['To', 'Cc', 'Bcc']... |
def prepare(self, mime):
"""
Prepares a MIME object by applying the headers
to the *mime* object. Ignores any Bcc or
Resent-Bcc headers.
"""
for key in self:
if key == 'Bcc' or key == 'Resent-Bcc':
continue
del mime[key]
... |
def tls(force=False):
"""
Middleware implementing TLS for SMTP connections. By
default this is not forced- TLS is only used if
STARTTLS is available. If the *force* parameter is set
to True, it will not query the server for TLS features
before upgrading to TLS.
"""
def middleware(conn):
... |
def auth(username, password):
"""
Middleware implementing authentication via LOGIN.
Most of the time this middleware needs to be placed
*after* TLS.
:param username: Username to login with.
:param password: Password of the user.
"""
def middleware(conn):
conn.login(username, pas... |
def get_existing_model(model_name):
""" Try to find existing model class named `model_name`.
:param model_name: String name of the model class.
"""
try:
model_cls = engine.get_document_cls(model_name)
log.debug('Model `{}` already exists. Using existing one'.format(
model_na... |
def prepare_relationship(config, model_name, raml_resource):
""" Create referenced model if it doesn't exist.
When preparing a relationship, we check to see if the model that will be
referenced already exists. If not, it is created so that it will be possible
to use it in a relationship. Thus the first... |
def generate_model_cls(config, schema, model_name, raml_resource,
es_based=True):
""" Generate model class.
Engine DB field types are determined using `type_fields` and only those
types may be used.
:param schema: Model schema dict parsed from RAML.
:param model_name: String... |
def setup_data_model(config, raml_resource, model_name):
""" Setup storage/data model and return generated model class.
Process follows these steps:
* Resource schema is found and restructured by `resource_schema`.
* Model class is generated from properties dict using util function
`generat... |
def handle_model_generation(config, raml_resource):
""" Generates model name and runs `setup_data_model` to get
or generate actual model class.
:param raml_resource: Instance of ramlfications.raml.ResourceNode.
"""
model_name = generate_model_name(raml_resource)
try:
return setup_data_m... |
def setup_model_event_subscribers(config, model_cls, schema):
""" Set up model event subscribers.
:param config: Pyramid Configurator instance.
:param model_cls: Model class for which handlers should be connected.
:param schema: Dict of model JSON schema.
"""
events_map = get_events_map()
m... |
def setup_fields_processors(config, model_cls, schema):
""" Set up model fields' processors.
:param config: Pyramid Configurator instance.
:param model_cls: Model class for field of which processors should be
set up.
:param schema: Dict of model JSON schema.
"""
properties = schema.get(... |
def _setup_ticket_policy(config, params):
""" Setup Pyramid AuthTktAuthenticationPolicy.
Notes:
* Initial `secret` params value is considered to be a name of config
param that represents a cookie name.
* `auth_model.get_groups_by_userid` is used as a `callback`.
* Also connects basic ... |
def _setup_apikey_policy(config, params):
""" Setup `nefertari.ApiKeyAuthenticationPolicy`.
Notes:
* User may provide model name in :params['user_model']: do define
the name of the user model.
* `auth_model.get_groups_by_token` is used to perform username and
token check
* `au... |
def setup_auth_policies(config, raml_root):
""" Setup authentication, authorization policies.
Performs basic validation to check all the required values are present
and performs authentication, authorization policies generation using
generator functions from `AUTHENTICATION_POLICIES`.
:param confi... |
def get_authuser_model():
""" Define and return AuthUser model using nefertari base classes """
from nefertari.authentication.models import AuthUserMixin
from nefertari import engine
class AuthUser(AuthUserMixin, engine.BaseDocument):
__tablename__ = 'ramses_authuser'
return AuthUser |
def validate_permissions(perms):
""" Validate :perms: contains valid permissions.
:param perms: List of permission names or ALL_PERMISSIONS.
"""
if not isinstance(perms, (list, tuple)):
perms = [perms]
valid_perms = set(PERMISSIONS.values())
if ALL_PERMISSIONS in perms:
return p... |
def parse_permissions(perms):
""" Parse permissions ("perms") which are either exact permission
names or the keyword 'all'.
:param perms: List or comma-separated string of nefertari permission
names, or 'all'
"""
if isinstance(perms, six.string_types):
perms = perms.split(',')
p... |
def parse_acl(acl_string):
""" Parse raw string :acl_string: of RAML-defined ACLs.
If :acl_string: is blank or None, all permissions are given.
Values of ACL action and principal are parsed using `actions` and
`special_principals` maps and are looked up after `strip()` and
`lower()`.
ACEs in :... |
def generate_acl(config, model_cls, raml_resource, es_based=True):
""" Generate an ACL.
Generated ACL class has a `item_model` attribute set to
:model_cls:.
ACLs used for collection and item access control are generated from a
first security scheme with type `x-ACL`.
If :raml_resource: has no ... |
def _apply_callables(self, acl, obj=None):
""" Iterate over ACEs from :acl: and apply callable principals
if any.
Principals are passed 3 arguments on call:
:ace: Single ACE object that looks like (action, callable,
permission or [permission])
:request: C... |
def item_acl(self, item):
""" Objectify ACL if ES is used or call item.get_acl() if
db is used.
"""
if self.es_based:
from nefertari_guards.elasticsearch import get_es_item_acl
return get_es_item_acl(item)
return super(DatabaseACLMixin, self).item_acl(item... |
def getitem_es(self, key):
""" Override to support ACL filtering.
To do so: passes `self.request` to `get_item` and uses
`ACLFilterES`.
"""
from nefertari_guards.elasticsearch import ACLFilterES
es = ACLFilterES(self.item_model.__name__)
params = {
'i... |
def convert_schema(raml_schema, mime_type):
""" Restructure `raml_schema` to a dictionary that has 'properties'
as well as other schema keys/values.
The resulting dictionary looks like this::
{
"properties": {
"field1": {
"required": boolean,
"type":... |
def generate_model_name(raml_resource):
""" Generate model name.
:param raml_resource: Instance of ramlfications.raml.ResourceNode.
"""
resource_uri = get_resource_uri(raml_resource).strip('/')
resource_uri = re.sub('\W', ' ', resource_uri)
model_name = inflection.titleize(resource_uri)
ret... |
def dynamic_part_name(raml_resource, route_name, pk_field):
""" Generate a dynamic part for a resource :raml_resource:.
A dynamic part is generated using 2 parts: :route_name: of the
resource and the dynamic part of first dynamic child resources. If
:raml_resource: has no dynamic child resources, 'id' ... |
def extract_dynamic_part(uri):
""" Extract dynamic url part from :uri: string.
:param uri: URI string that may contain dynamic part.
"""
for part in uri.split('/'):
part = part.strip()
if part.startswith('{') and part.endswith('}'):
return clean_dynamic_uri(part) |
def resource_view_attrs(raml_resource, singular=False):
""" Generate view method names needed for `raml_resource` view.
Collects HTTP method names from resource siblings and dynamic children
if exist. Collected methods are then translated to
`nefertari.view.BaseView` method names, each of which is use... |
def resource_schema(raml_resource):
""" Get schema properties of RAML resource :raml_resource:.
Must be called with RAML resource that defines body schema. First
body that defines schema is used. Schema is converted on return using
'convert_schema'.
:param raml_resource: Instance of ramlfications.... |
def get_static_parent(raml_resource, method=None):
""" Get static parent resource of :raml_resource: with HTTP
method :method:.
:param raml_resource:Instance of ramlfications.raml.ResourceNode.
:param method: HTTP method name which matching static resource
must have.
"""
parent = raml_r... |
def attr_subresource(raml_resource, route_name):
""" Determine if :raml_resource: is an attribute subresource.
:param raml_resource: Instance of ramlfications.raml.ResourceNode.
:param route_name: Name of the :raml_resource:.
"""
static_parent = get_static_parent(raml_resource, method='POST')
i... |
def singular_subresource(raml_resource, route_name):
""" Determine if :raml_resource: is a singular subresource.
:param raml_resource: Instance of ramlfications.raml.ResourceNode.
:param route_name: Name of the :raml_resource:.
"""
static_parent = get_static_parent(raml_resource, method='POST')
... |
def is_callable_tag(tag):
""" Determine whether :tag: is a valid callable string tag.
String is assumed to be valid callable if it starts with '{{'
and ends with '}}'.
:param tag: String name of tag.
"""
return (isinstance(tag, six.string_types) and
tag.strip().startswith('{{') and... |
def resolve_to_callable(callable_name):
""" Resolve string :callable_name: to a callable.
:param callable_name: String representing callable name as registered
in ramses registry or dotted import path of callable. Can be
wrapped in double curly brackets, e.g. '{{my_callable}}'.
"""
from... |
def get_resource_siblings(raml_resource):
""" Get siblings of :raml_resource:.
:param raml_resource: Instance of ramlfications.raml.ResourceNode.
"""
path = raml_resource.path
return [res for res in raml_resource.root.resources
if res.path == path] |
def get_resource_children(raml_resource):
""" Get children of :raml_resource:.
:param raml_resource: Instance of ramlfications.raml.ResourceNode.
"""
path = raml_resource.path
return [res for res in raml_resource.root.resources
if res.parent and res.parent.path == path] |
def get_events_map():
""" Prepare map of event subscribers.
* Extends copies of BEFORE_EVENTS and AFTER_EVENTS maps with
'set' action.
* Returns map of {before/after: {action: event class(es)}}
"""
from nefertari import events
set_keys = ('create', 'update', 'replace', 'update_many', 'r... |
def patch_view_model(view_cls, model_cls):
""" Patches view_cls.Model with model_cls.
:param view_cls: View class "Model" param of which should be
patched
:param model_cls: Model class which should be used to patch
view_cls.Model
"""
original_model = view_cls.Model
view_cls.Mode... |
def get_route_name(resource_uri):
""" Get route name from RAML resource URI.
:param resource_uri: String representing RAML resource URI.
:returns string: String with route name, which is :resource_uri:
stripped of non-word characters.
"""
resource_uri = resource_uri.strip('/')
resource_... |
def generate_resource(config, raml_resource, parent_resource):
""" Perform complete one resource configuration process
This function generates: ACL, view, route, resource, database
model for a given `raml_resource`. New nefertari resource is
attached to `parent_resource` class which is an instance of
... |
def generate_server(raml_root, config):
""" Handle server generation process.
:param raml_root: Instance of ramlfications.raml.RootNode.
:param config: Pyramid Configurator instance.
"""
log.info('Server generation started')
if not raml_root.resources:
return
root_resource = confi... |
def generate_models(config, raml_resources):
""" Generate model for each resource in :raml_resources:
The DB model name is generated using singular titled version of current
resource's url. E.g. for resource under url '/stories', model with
name 'Story' will be generated.
:param config: Pyramid Co... |
def generate_rest_view(config, model_cls, attrs=None, es_based=True,
attr_view=False, singular=False):
""" Generate REST view for a model class.
:param model_cls: Generated DB model class.
:param attr: List of strings that represent names of view methods, new
generated view s... |
def set_object_acl(self, obj):
""" Set object ACL on creation if not already present. """
if not obj._acl:
from nefertari_guards import engine as guards_engine
acl = self._factory(self.request).generate_item_acl(obj)
obj._acl = guards_engine.ACLField.stringify_acl(acl... |
def resolve_kw(self, kwargs):
""" Resolve :kwargs: like `story_id: 1` to the form of `id: 1`.
"""
resolved = {}
for key, value in kwargs.items():
split = key.split('_', 1)
if len(split) > 1:
key = split[1]
resolved[key] = value
... |
def _location(self, obj):
""" Get location of the `obj`
Arguments:
:obj: self.Model instance.
"""
field_name = self.clean_id_name
return self.request.route_url(
self._resource.uid,
**{self._resource.id_name: getattr(obj, field_name)}) |
def _parent_queryset(self):
""" Get queryset of parent view.
Generated queryset is used to run queries in the current level view.
"""
parent = self._resource.parent
if hasattr(parent, 'view'):
req = self.request.blank(self.request.path)
req.registry = sel... |
def get_collection(self, **kwargs):
""" Get objects collection taking into account generated queryset
of parent view.
This method allows working with nested resources properly. Thus a
queryset returned by this method will be a subset of its parent
view's queryset, thus filtering... |
def get_item(self, **kwargs):
""" Get collection item taking into account generated queryset
of parent view.
This method allows working with nested resources properly. Thus an item
returned by this method will belong to its parent view's queryset, thus
filtering out objects that... |
def reload_context(self, es_based, **kwargs):
""" Reload `self.context` object into a DB or ES object.
A reload is performed by getting the object ID from :kwargs: and then
getting a context key item from the new instance of `self._factory`
which is an ACL class used by the current view... |
def _parent_queryset_es(self):
""" Get queryset (list of object IDs) of parent view.
The generated queryset is used to run queries in the current level's
view.
"""
parent = self._resource.parent
if hasattr(parent, 'view'):
req = self.request.blank(self.reques... |
def get_es_object_ids(self, objects):
""" Return IDs of :objects: if they are not IDs already. """
id_field = self.clean_id_name
ids = [getattr(obj, id_field, obj) for obj in objects]
return list(set(str(id_) for id_ in ids)) |
def get_collection_es(self):
""" Get ES objects collection taking into account the generated
queryset of parent view.
This method allows working with nested resources properly. Thus a
queryset returned by this method will be a subset of its parent view's
queryset, thus filtering... |
def get_item_es(self, **kwargs):
""" Get ES collection item taking into account generated queryset
of parent view.
This method allows working with nested resources properly. Thus an item
returned by this method will belong to its parent view's queryset, thus
filtering out object... |
def update(self, **kwargs):
""" Explicitly reload context with DB usage to get access
to complete DB object.
"""
self.reload_context(es_based=False, **kwargs)
return super(ESCollectionView, self).update(**kwargs) |
def delete(self, **kwargs):
""" Explicitly reload context with DB usage to get access
to complete DB object.
"""
self.reload_context(es_based=False, **kwargs)
return super(ESCollectionView, self).delete(**kwargs) |
def get_dbcollection_with_es(self, **kwargs):
""" Get DB objects collection by first querying ES. """
es_objects = self.get_collection_es()
db_objects = self.Model.filter_objects(es_objects)
return db_objects |
def delete_many(self, **kwargs):
""" Delete multiple objects from collection.
First ES is queried, then the results are used to query the DB.
This is done to make sure deleted objects are those filtered
by ES in the 'index' method (so user deletes what he saw).
"""
db_ob... |
def update_many(self, **kwargs):
""" Update multiple objects from collection.
First ES is queried, then the results are used to query DB.
This is done to make sure updated objects are those filtered
by ES in the 'index' method (so user updates what he saw).
"""
db_object... |
def _get_context_key(self, **kwargs):
""" Get value of `self._resource.parent.id_name` from :kwargs: """
return str(kwargs.get(self._resource.parent.id_name)) |
def get_item(self, **kwargs):
""" Reload context on each access. """
self.reload_context(es_based=False, **kwargs)
return super(ItemSubresourceBaseView, self).get_item(**kwargs) |
def setup(app):
"""Allow this module to be used as sphinx extension.
This attaches the Sphinx hooks.
:type app: sphinx.application.Sphinx
"""
import sphinxcontrib_django.docstrings
import sphinxcontrib_django.roles
# Setup both modules at once. They can also be separately imported to
#... |
def patch_django_for_autodoc():
"""Fix the appearance of some classes in autodoc.
This avoids query evaluation.
"""
# Fix Django's manager appearance
ManagerDescriptor.__get__ = lambda self, *args, **kwargs: self.manager
# Stop Django from executing DB queries
models.QuerySet.__repr__ = la... |
def setup(app):
"""Allow this package to be used as Sphinx extension.
This is also called from the top-level ``__init__.py``.
:type app: sphinx.application.Sphinx
"""
from .patches import patch_django_for_autodoc
# When running, make sure Django doesn't execute querysets
patch_django_for_a... |
def autodoc_skip(app, what, name, obj, skip, options):
"""Hook that tells autodoc to include or exclude certain fields.
Sadly, it doesn't give a reference to the parent object,
so only the ``name`` can be used for referencing.
:type app: sphinx.application.Sphinx
:param what: The parent type, ``cl... |
def improve_model_docstring(app, what, name, obj, options, lines):
"""Hook that improves the autodoc docstrings for Django models.
:type app: sphinx.application.Sphinx
:param what: The parent type, ``class`` or ``module``
:type what: str
:param name: The dotted path to the child method/attribute.
... |
def _improve_class_docs(app, cls, lines):
"""Improve the documentation of a class."""
if issubclass(cls, models.Model):
_add_model_fields_as_params(app, cls, lines)
elif issubclass(cls, forms.Form):
_add_form_fields(cls, lines) |
def _add_model_fields_as_params(app, obj, lines):
"""Improve the documentation of a Django model subclass.
This adds all model fields as parameters to the ``__init__()`` method.
:type app: sphinx.application.Sphinx
:type lines: list
"""
for field in obj._meta.get_fields():
try:
... |
def _add_form_fields(obj, lines):
"""Improve the documentation of a Django Form class.
This highlights the available fields in the form.
"""
lines.append("**Form fields:**")
lines.append("")
for name, field in obj.base_fields.items():
field_type = "{}.{}".format(field.__class__.__module... |
def _improve_attribute_docs(obj, name, lines):
"""Improve the documentation of various attributes.
This improves the navigation between related objects.
:param obj: the instance of the object to document.
:param name: full dotted path to the object.
:param lines: expected documentation lines.
"... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.