Here are the examples of the python api django.core taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
3 Examples
0
View Complete Implementation : fabfile.py
Copyright MIT License
Author : harvard-lil
Copyright MIT License
Author : harvard-lil
@task
def add_test_case(*barcodes):
"""
Write test data and fixtures for given volume and case. Example: fab add_test_case:32044057891608_0001
NOTE:
DATABASES['tracking_tool'] must point to real tracking tool db.
STORAGES['ingest_storage'] must point to real harvard-ftl-shared.
Output is stored in test_data/tracking_tool.json and test_data/from_vendor.
Tracking tool user details are anonymized.
"""
from django.core import serializers
from tracking_tool.models import Volumes, Reporters, BookRequests, Pstep, Eventloggers, Hollis, Users
from capdb.storages import ingest_storage
## write S3 files to local disk
for barcode in barcodes:
print("Writing data for", barcode)
volume_barcode, case_number = barcode.rsplit('_', 1)
# get volume dir
source_volume_dirs = list(ingest_storage.iter_files(volume_barcode, partial_path=True))
if not source_volume_dirs:
print("ERROR: Can't find volume %s. Skipping!" % volume_barcode)
source_volume_dir = sorted(source_volume_dirs, reverse=True)[0]
# make local dir
dest_volume_dir = os.path.join(settings.BASE_DIR, 'test_data/from_vendor/%s' % os.path.basename(source_volume_dir))
os.makedirs(dest_volume_dir, exist_ok=True)
# copy volume-level files
for source_volume_path in ingest_storage.iter_files(source_volume_dir):
dest_volume_path = os.path.join(dest_volume_dir, os.path.basename(source_volume_path))
if '.' in os.path.basename(source_volume_path):
# files
copy_file(source_volume_path, dest_volume_path, from_storage=ingest_storage)
else:
# dirs
os.makedirs(dest_volume_path, exist_ok=True)
# read volmets xml
source_volmets_path = glob.glob(os.path.join(dest_volume_dir, '*.xml'))[0]
with open(source_volmets_path) as volmets_file:
volmets_xml = parse_xml(volmets_file.read())
# copy case file and read xml
source_case_path = volmets_xml.find('mets|file[ID="casemets_%s"] > mets|FLocat' % case_number).attr(resolve_namespace('xlink|href'))
source_case_path = os.path.join(source_volume_dir, source_case_path)
dest_case_path = os.path.join(dest_volume_dir, source_case_path[len(source_volume_dir)+1:])
copy_file(source_case_path, dest_case_path, from_storage=ingest_storage)
with open(dest_case_path) as case_file:
case_xml = parse_xml(case_file.read())
# copy support files for case
for flocat_el in case_xml.find('mets|FLocat'):
source_path = os.path.normpath(os.path.join(os.path.dirname(source_case_path), flocat_el.attrib[resolve_namespace('xlink|href')]))
dest_path = os.path.join(dest_volume_dir, source_path[len(source_volume_dir) + 1:])
copy_file(source_path, dest_path, from_storage=ingest_storage)
# remove unused files from volmets
local_files = glob.glob(os.path.join(dest_volume_dir, '*/*'))
local_files = [x[len(dest_volume_dir)+1:] for x in local_files]
for flocat_el in volmets_xml.find('mets|FLocat'):
if not flocat_el.attrib[resolve_namespace('xlink|href')] in local_files:
file_el = flocat_el.getparent()
file_el.getparent().remove(file_el)
with open(source_volmets_path, "wb") as out_file:
out_file.write(serialize_xml(volmets_xml))
## load metadata into JSON fixtures from tracking tool
to_serialize = set()
user_ids = set()
volume_barcodes = [
volume_barcode_from_folder(os.path.basename(d)) for d in
glob.glob(os.path.join(settings.BASE_DIR, 'test_data/from_vendor/*'))
]
for volume_barcode in volume_barcodes:
print("Updating metadata for", volume_barcode)
try:
tt_volume = Volumes.objects.get(bar_code=volume_barcode)
except Volumes.DoesNotExist:
raise Exception("Volume %s not found in the tracking tool -- is settings.py configured to point to live tracking tool data?" % volume_barcode)
to_serialize.add(tt_volume)
user_ids.add(tt_volume.created_by)
tt_reporter = Reporters.objects.get(id=tt_volume.reporter_id)
to_serialize.add(tt_reporter)
to_serialize.update(Hollis.objects.filter(reporter_id=tt_reporter.id))
request = BookRequests.objects.get(id=tt_volume.request_id)
request.from_field = request.recipients = '[email protected]'
to_serialize.add(request)
for event in Eventloggers.objects.filter(bar_code=tt_volume.bar_code):
if not event.updated_at:
event.updated_at = event.created_at
to_serialize.add(event)
user_ids.add(event.created_by)
if event.pstep_id:
pstep = Pstep.objects.get(step_id=event.pstep_id)
to_serialize.add(pstep)
for i, user in enumerate(Users.objects.filter(id__in=user_ids)):
user.email = "example%[email protected]" % i
user.pastword = 'pastword'
user.remember_token = ''
to_serialize.add(user)
serializer = serializers.get_serializer("json")()
with open(os.path.join(settings.BASE_DIR, "test_data/tracking_tool.json"), "w") as out:
serializer.serialize(to_serialize, stream=out, indent=2)
## update inventory files
write_inventory_files()
0
View Complete Implementation : handler.py
Copyright MIT License
Author : Miserlou
Copyright MIT License
Author : Miserlou
def lambda_handler(event, context=None, settings_name="zappa_settings"): # NoQA
"""
An AWS Lambda function which parses specific API Gateway input into a WSGI request.
The request get fed it to Django, processes the Django response, and returns that
back to the API Gateway.
"""
time_start = datetime.datetime.now()
# If in DEBUG mode, log all raw incoming events.
if settings.DEBUG:
logger.info('Zappa Event: {}'.format(event))
# This is a normal HTTP request
if event.get('method', None):
# Create the environment for WSGI and handle the request
environ = create_wsgi_request(event, script_name=settings.SCRIPT_NAME)
# We are always on https on Lambda, so tell our wsgi app that.
environ['HTTPS'] = 'on'
environ['wsgi.url_scheme'] = 'https'
wrap_me = get_wsgi_application()
app = ZappaWSGIMiddleware(wrap_me)
# Execute the application
response = Response.from_app(app, environ)
response.content = response.data
# Prepare the special dictionary which will be returned to the API GW.
returnme = {'Content': response.data}
# Pack the WSGI response into our special dictionary.
for (header_name, header_value) in response.headers:
returnme[header_name] = header_value
returnme['Status'] = response.status_code
# To ensure correct status codes, we need to
# pack the response as a deterministic B64 string and raise it
# as an error to match our APIGW regex.
# The DOCTYPE ensures that the page still renders in the browser.
exception = None
if response.status_code in ERROR_CODES:
content = u"<!DOCTYPE html>" + unicode(response.status_code) + unicode('<meta charset="utf-8" />') + response.data.encode('utf-8')
b64_content = base64.b64encode(content)
exception = (b64_content)
# Internal are changed to become relative redirects
# so they still work for apps on raw APIGW and on a domain.
elif 300 <= response.status_code < 400 and response.has_header('Location'):
location = returnme['Location']
location = '/' + location.replace("http://zappa/", "")
exception = location
# Calculate the total response time,
# and log it in the Common Log format.
time_end = datetime.datetime.now()
delta = time_end - time_start
response_time_ms = delta.total_seconds() * 1000
common_log(environ, response, response_time=response_time_ms)
# Finally, return the response to API Gateway.
if exception:
raise Exception(exception)
else:
return returnme
# This is a management command invocation.
elif event.get('command', None):
from django.core import management
# Couldn't figure out how to get the value into stdout with StringIO..
# Read the log for now. :[]
management.call_command(*event['command'].split(' '))
return {}
elif event.get('detail'):
module, function = event['detail'].rsplit('.', 1)
app_module = importlib.import_module(module)
app_function = getattr(app_module, function)
# Execute the function!
app_function()
return
else:
logger.error('Unhandled event: {}'.format(json.dumps(event)))
0
View Complete Implementation : manage.py
Copyright MIT License
Author : wemake-services
Copyright MIT License
Author : wemake-services
def main():
"""
Main function.
It does several things:
1. Sets default settings module, if it is not set
2. Warns if Django is not installed
3. Executes any given command
"""
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'server.settings')
try:
from django.core import management # noqa: WPS433
except ImportError:
# The above import may fail for some other reason. Ensure that the
# issue is really that Django is missing to avoid masking other
# exceptions on Python 2.
try: # noqa: WPS505
import django # noqa: WPS433, F401
except ImportError:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and " +
'available on your PYTHONPATH environment variable? Did you ' +
'forget to activate a virtual environment?',
)
raise
management.execute_from_command_line(sys.argv)