function
stringlengths 11
56k
| repo_name
stringlengths 5
60
| features
sequence |
---|---|---|
def _on_size_spin_button_value_changed(self, size_spin_button):
if self._locker.is_unlocked("emit_size_spin_button_value_changed"):
self._locker.lock("update_spin_button") | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def _on_item_button_remove_clicked(self, button, item):
self._locker.lock("emit_size_spin_button_value_changed") | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def _on_item_widget_size_allocate(self, item_widget, allocation, item):
if item in self._items_allocations:
self._update_width(allocation.width - self._items_allocations[item].width)
self._update_height(allocation.height - self._items_allocations[item].height)
else:
self._update_width(allocation.width)
self._update_height(allocation.height + self._item_spacing) | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def _update_width(self, width_diff):
if self._items_total_width is None:
self._items_total_width = self.get_allocation().width | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def _update_height(self, height_diff):
if self._items_total_height is None:
self._items_total_height = self.get_allocation().height | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def _update_dimension(
self,
size_diff,
total_size,
max_visible_size,
dimension_request_property):
if max_visible_size is None:
is_max_visible_size_unlimited = True
else:
is_max_visible_size_unlimited = max_visible_size <= 0 | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def _rename_item_names(self, start_index):
for index, item in enumerate(self._items[start_index:]):
item.label.set_label(self._get_item_name(index + 1 + start_index)) | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def _get_item_name(index):
return _("Element") + " " + str(index) | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def __init__(self, item_widget):
super().__init__(item_widget) | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def label(self):
return self._label | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def __init__(self):
self._tokens = collections.defaultdict(int) | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def lock_temp(self, key):
self.lock(key)
try:
yield
finally:
self.unlock(key) | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def lock(self, key):
self._tokens[key] += 1 | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def unlock(self, key):
if self._tokens[key] > 0:
self._tokens[key] -= 1 | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def is_locked(self, key):
return self._tokens[key] > 0 | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def is_unlocked(self, key):
return self._tokens[key] == 0 | khalim19/gimp-plugin-export-layers | [
522,
38,
522,
29,
1403878280
] |
def filter_ring(points, center, rminmax):
"""Filter points to be in a certain radial distance range from center.
Parameters
----------
points : np.ndarray
Candidate points.
center : np.ndarray or tuple
Center position.
rminmax : tuple
Tuple of min and max radial distance.
Returns
-------
: np.ndarray
List of filtered points, two column array.
""" | ercius/openNCEM | [
44,
23,
44,
2,
1479513928
] |
def points_topolar(points, center):
"""Convert points to polar coordinate system.
Can be either in pixel or real dim, but should be the same for points and center.
Parameters
----------
points : np.ndarray
Positions as two column array.
center : np.ndarray or tuple
Origin of the polar coordinate system.
Returns
-------
: np.ndarray
Positions in polar coordinate system as two column array (r, theta).
""" | ercius/openNCEM | [
44,
23,
44,
2,
1479513928
] |
def residuals_center( param, data):
"""Residual function for minimizing the deviations from the mean radial distance.
Parameters
----------
param : np.ndarray
The center to optimize.
data : np.ndarray
The points in x,y coordinates of the original image.
Returns
-------
: np.ndarray
Residuals.
""" | ercius/openNCEM | [
44,
23,
44,
2,
1479513928
] |
def optimize_center(points, center, maxfev=1000, verbose=None):
"""Optimize the center by minimizing the sum of square deviations from the mean radial distance.
Parameters
----------
points : np.ndarray
The points to which the optimization is done (x,y coords in org image).
center : np.ndarray or tuple
Initial center guess.
maxfev : int
Max number of iterations forwarded to scipy.optimize.leastsq().
verbose : bool
Set to get verbose output.
Returns
-------
: np.ndarray
The optimized center.
"""
try:
# points have to be 2D array with 2 columns
assert(isinstance(points, np.ndarray))
assert(points.shape[1] == 2)
assert(len(points.shape) == 2) | ercius/openNCEM | [
44,
23,
44,
2,
1479513928
] |
def rad_dis(theta, alpha, beta, order=2):
"""Radial distortion due to ellipticity or higher order distortion.
Relative distortion, to be multiplied with radial distance.
Parameters
----------
theta : np.ndarray
Angles at which to evaluate. Must be float.
alpha : float
Orientation of major axis.
beta : float
Strength of distortion (beta = (1-r_min/r_max)/(1+r_min/r_max).
order : int
Order of distortion.
Returns
-------
: np.ndarray
Distortion factor.
""" | ercius/openNCEM | [
44,
23,
44,
2,
1479513928
] |
def residuals_dis(param, points, ns):
"""Residual function for distortions.
Parameters
----------
param : np.ndarray
Parameters for distortion.
points : np.ndarray
Points to fit to.
ns : tuple
List of orders to account for.
Returns
-------
: np.ndarray
Residuals.
"""
est = param[0]*np.ones(points[:, 1].shape)
for i in range(len(ns)):
est *=rad_dis(points[:, 1], param[i*2+1], param[i*2+2], ns[i]) | ercius/openNCEM | [
44,
23,
44,
2,
1479513928
] |
def optimize_distortion(points, ns, maxfev=1000, verbose=False):
"""Optimize distortions.
The orders in the list ns are first fitted subsequently and the result is refined in a final fit simultaneously fitting all orders.
Parameters
----------
points : np.ndarray
Points to optimize to (in polar coords).
ns : tuple
List of orders to correct for.
maxfev : int
Max number of iterations forwarded to scipy.optimize.leastsq().
verbose : bool
Set for verbose output.
Returns
-------
: np.ndarray
Optimized parameters according to ns.
""" | ercius/openNCEM | [
44,
23,
44,
2,
1479513928
] |
def home_view(request):
topics = []
organized_topics = defaultdict(list)
for tag in Tag.tags.public().top_level():
child_tags = tag.children.values_list('id')
resource_count = Resource.objects.filter(status=Resource.APPROVED).filter(
Q(resourcetag__tag__pk__in=child_tags) | Q(resourcetag__tag=tag)).distinct().count()
for category_slug in ["health-domain"]:
if tag.category.slug == category_slug:
organized_topics[category_slug.replace("-", "_")].append({
'resource_count': resource_count,
'tag': tag,
})
topics.append({
'resource_count': resource_count,
'tag': tag,
})
return render(request, 'orb/home.html', {
'topics': topics,
'organized_topics': home_resources(),
'page_title': _(u'ORB by mPowering'),
}) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def tag_view(request, tag_slug):
"""
Renders a tag detail page.
Allows the user to paginate resultes and sort by preselected options.
Args:
request: HttpRequest
tag_slug: the identifier for the tag
Returns:
Rendered response with a tag's resource list
"""
tag = get_object_or_404(Tag, slug=tag_slug)
filter_params = {
'page': 1,
'order': TagPageForm.CREATED,
}
params_form = TagPageForm(data=request.GET)
if params_form.is_valid():
filter_params.update(params_form.cleaned_data)
order_by = filter_params['order']
if order_by == TagPageForm.RATING:
data = Resource.resources.approved().with_ratings(tag).order_by(order_by)
else:
data = Resource.resources.approved().for_tag(tag).order_by(order_by)
paginator = Paginator(data, settings.ORB_PAGINATOR_DEFAULT)
try:
resources = paginator.page(filter_params['page'])
except (EmptyPage, InvalidPage):
resources = paginator.page(paginator.num_pages)
show_filter_link = tag.category.slug in [slug for name, slug in settings.ADVANCED_SEARCH_CATEGORIES]
tag_viewed.send(sender=tag, tag=tag, request=request)
is_geo_tag = tag.category.name == "Geography"
return render(request, 'orb/tag.html', {
'tag': tag,
'page': resources,
'params_form': params_form,
'show_filter_link': show_filter_link,
'is_geo_tag': is_geo_tag,
}) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_permalink_view(request, id):
resource = get_object_or_404(Resource, pk=id)
return resource_view(request, resource.slug) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_create_step1_view(request):
if request.user.is_anonymous():
return render(request, 'orb/login_required.html', {
'message': _(u'You need to be logged in to add a resource.'),
})
if request.method == 'POST':
form = ResourceStep1Form(request.POST, request.FILES, request=request)
resource_form_set_choices(form)
if form.is_valid():
# save resource
resource = Resource(status=Resource.PENDING,
create_user=request.user, update_user=request.user)
resource.title = form.cleaned_data.get("title")
resource.description = form.cleaned_data.get("description")
if form.cleaned_data.get("study_time_number") and form.cleaned_data.get("study_time_unit"):
resource.study_time_number = form.cleaned_data.get(
"study_time_number")
resource.study_time_unit = form.cleaned_data.get(
"study_time_unit")
if request.FILES.has_key('image'):
resource.image = request.FILES["image"]
resource.attribution = form.cleaned_data.get("attribution")
resource.save()
# add organisation(s)/geography and other tags
resource_add_free_text_tags(
resource, form.cleaned_data.get('organisations'), request.user, 'organisation')
resource_add_free_text_tags(
resource, form.cleaned_data.get('geography'), request.user, 'geography')
resource_add_free_text_tags(
resource, form.cleaned_data.get('languages'), request.user, 'language')
resource_add_free_text_tags(
resource, form.cleaned_data.get('other_tags'), request.user, 'other')
# add tags
resource_add_tags(request, form, resource)
# see if email needs to be sent
resource_workflow.send(sender=resource, resource=resource, request=request,
status=Resource.PENDING, notes="")
resource_submitted.send(sender=resource, resource=resource, request=request)
# redirect to step 2
# Redirect after POST
return HttpResponseRedirect(reverse('orb_resource_create2', args=[resource.id]))
else:
if request.user.userprofile.organisation:
user_org = request.user.userprofile.organisation.name
initial = {'organisations': user_org, }
else:
initial = {}
form = ResourceStep1Form(initial=initial, request=request)
resource_form_set_choices(form)
return render(request, 'orb/resource/create_step1.html', {'form': form}) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_create_file_delete_view(request, id, file_id):
# check ownership
resource = get_object_or_404(Resource, pk=id)
if not resource_can_edit(resource, request.user):
raise Http404()
try:
ResourceFile.objects.get(resource=resource, pk=file_id).delete()
except ResourceFile.DoesNotExist:
pass
return HttpResponseRedirect(reverse('orb_resource_create2', args=[id])) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_edit_file_delete_view(request, id, file_id):
# check ownership
resource = get_object_or_404(Resource, pk=id)
if not resource_can_edit(resource, request.user):
raise Http404()
try:
ResourceFile.objects.get(resource=resource, pk=file_id).delete()
except ResourceFile.DoesNotExist:
pass
return HttpResponseRedirect(reverse('orb_resource_edit2', args=[id])) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_create_thanks_view(request, id):
resource = get_object_or_404(Resource, pk=id)
if not resource_can_edit(resource, request.user):
raise Http404()
return render(request, 'orb/resource/create_thanks.html', {'resource': resource}) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_approve_view(request, id):
if not request.user.is_staff:
return HttpResponse(status=401, content="Not Authorized")
resource = Resource.objects.get(pk=id)
resource.status = Resource.APPROVED
resource.save()
resource_workflow.send(sender=resource, resource=resource,
request=request, status=Resource.APPROVED, notes="")
return render(request, 'orb/resource/status_updated.html', {'resource': resource}) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_reject_sent_view(request, id):
if not request.user.is_staff:
return HttpResponse(status=401, content="Not Authorized")
resource = Resource.objects.get(pk=id)
return render(request, 'orb/resource/status_updated.html', {'resource': resource, }) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_edit_view(request, resource_id):
resource = get_object_or_404(Resource, pk=resource_id)
if not resource_can_edit(resource, request.user):
raise Http404()
if request.method == 'POST':
form = ResourceStep1Form(data=request.POST, files=request.FILES)
resource_form_set_choices(form)
if form.is_valid():
resource.update_user = request.user
resource.title = form.cleaned_data.get("title")
resource.description = form.cleaned_data.get("description")
if form.cleaned_data.get("study_time_number") and form.cleaned_data.get("study_time_unit"):
resource.study_time_number = form.cleaned_data.get(
"study_time_number")
resource.study_time_unit = form.cleaned_data.get(
"study_time_unit")
resource.attribution = form.cleaned_data.get("attribution")
resource.save()
# update image
image = form.cleaned_data.get("image")
if image == False:
resource.image = None
resource.save()
if request.FILES.has_key('image'):
resource.image = request.FILES["image"]
resource.save()
# update tags - remove all current tags first
ResourceTag.objects.filter(resource=resource).delete()
resource_add_tags(request, form, resource)
resource_add_free_text_tags(
resource, form.cleaned_data.get('organisations'), request.user, 'organisation')
resource_add_free_text_tags(
resource, form.cleaned_data.get('geography'), request.user, 'geography')
resource_add_free_text_tags(
resource, form.cleaned_data.get('languages'), request.user, 'language')
resource_add_free_text_tags(
resource, form.cleaned_data.get('other_tags'), request.user, 'other')
# All successful - now redirect
# Redirect after POST
return HttpResponseRedirect(reverse('orb_resource_edit2', args=[resource.id]))
else:
initial = request.POST.copy()
initial['image'] = resource.image
files = ResourceFile.objects.filter(resource=resource)[:1]
if files:
initial['file'] = files[0].file
form = ResourceStep1Form(
initial=initial, data=request.POST, files=request.FILES)
resource_form_set_choices(form)
else:
data = {}
data['title'] = resource.title
organisations = Tag.objects.filter(
category__slug='organisation', resourcetag__resource=resource).values_list('name', flat=True)
data['organisations'] = ', '.join(organisations)
data['description'] = resource.description
data['image'] = resource.image
data['study_time_number'] = resource.study_time_number
data['study_time_unit'] = resource.study_time_unit
data['attribution'] = resource.attribution
files = ResourceFile.objects.filter(resource=resource)[:1]
if files:
data['file'] = files[0].file
urls = ResourceURL.objects.filter(resource=resource)[:1]
if urls:
data['url'] = urls[0].url
health_topic = Tag.objects.filter(
category__top_level=True, resourcetag__resource=resource).values_list('id', flat=True)
data['health_topic'] = health_topic
resource_type = Tag.objects.filter(
category__slug='type', resourcetag__resource=resource).values_list('id', flat=True)
data['resource_type'] = resource_type
audience = Tag.objects.filter(
category__slug='audience', resourcetag__resource=resource).values_list('id', flat=True)
data['audience'] = audience
geography = Tag.objects.filter(
category__slug='geography', resourcetag__resource=resource).values_list('name', flat=True)
data['geography'] = ', '.join(geography)
languages = Tag.objects.filter(
category__slug='language', resourcetag__resource=resource).values_list('name', flat=True)
data['languages'] = ', '.join(languages)
device = Tag.objects.filter(
category__slug='device', resourcetag__resource=resource).values_list('id', flat=True)
data['device'] = device
license = Tag.objects.filter(
category__slug='license', resourcetag__resource=resource).values_list('id', flat=True)
if license:
data['license'] = license[0]
other_tags = Tag.objects.filter(
resourcetag__resource=resource, category__slug='other').values_list('name', flat=True)
data['other_tags'] = ', '.join(other_tags)
form = ResourceStep1Form(initial=data)
resource_form_set_choices(form)
return render(request, 'orb/resource/edit.html', {'form': form}) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_edit_thanks_view(request, id):
resource = get_object_or_404(Resource, pk=id)
if not resource_can_edit(resource, request.user):
raise Http404()
return render(request, 'orb/resource/edit_thanks.html', {'resource': resource}) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def search_advanced_view(request, tag_id=None):
if request.method == 'POST':
form = AdvancedSearchForm(request.POST)
if form.is_valid():
urlparams = request.POST.copy()
# delete these from params as not required
del urlparams['csrfmiddlewaretoken']
del urlparams['submit']
return HttpResponseRedirect(reverse('orb_search_advanced_results') + "?" + urlparams.urlencode())
else:
form = AdvancedSearchForm()
return render(request, 'orb/search_advanced.html', {'form': form}) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def collection_view(request, collection_slug):
collection = get_object_or_404(Collection,
slug=collection_slug, visibility=Collection.PUBLIC)
data = Resource.objects.filter(collectionresource__collection=collection,
status=Resource.APPROVED).order_by('collectionresource__order_by')
paginator = Paginator(data, settings.ORB_PAGINATOR_DEFAULT)
try:
page = int(request.GET.get('page', '1'))
except ValueError:
page = 1
try:
resources = paginator.page(page)
except (EmptyPage, InvalidPage):
resources = paginator.page(paginator.num_pages)
return render(request, 'orb/collection/view.html', {
'collection': collection,
'page': resources,
'total_results': paginator.count,
}) | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_form_set_choices(form):
form.fields['health_topic'].choices = [(t.id, t.name) for t in Tag.objects.filter(
category__top_level=True).order_by('order_by', 'name')]
form.fields['resource_type'].choices = [(t.id, t.name) for t in Tag.objects.filter(
category__slug='type').order_by('order_by', 'name')]
form.fields['audience'].choices = [(t.id, t.name) for t in Tag.objects.filter(
category__slug='audience').order_by('order_by', 'name')]
form.fields['device'].choices = [(t.id, t.name) for t in Tag.objects.filter(
category__slug='device').order_by('order_by', 'name')]
form.fields['license'].choices = [(t.id, t.name) for t in Tag.objects.filter(
category__slug='license').order_by('order_by', 'name')]
return form | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def resource_can_edit(resource, user):
if user.is_staff or user == resource.create_user or user == resource.update_user:
return True
else:
return TagOwner.objects.filter(user__pk=user.id, tag__resourcetag__resource=resource).exists() | mPowering/django-orb | [
2,
10,
2,
81,
1420822795
] |
def giudizio_positivo(self, autore):
"""
Registra un giudizio positivo
:param autore: Autore del giudizio
"""
self._giudizio(autore, True) | CroceRossaItaliana/jorvik | [
29,
20,
29,
131,
1424890427
] |
def _giudizio(self, autore, positivo):
"""
Registra un giudizio
:param autore: Autore del giudizio
:param positivo: Vero se positivo, falso se negativo
"""
g = self.giudizio_cerca(autore)
if g: # Se gia' esiste un giudizio, modifico il tipo
g.positivo = positivo
else: # Altrimenti, ne registro uno nuovo
g = Giudizio(
oggetto=self,
positivo=positivo,
autore=autore
)
g.save() | CroceRossaItaliana/jorvik | [
29,
20,
29,
131,
1424890427
] |
def giudizi_positivi(self):
"""
Restituisce il numero di giudizi positivi associati all'oggetto.
"""
return self._giudizi(self, True) | CroceRossaItaliana/jorvik | [
29,
20,
29,
131,
1424890427
] |
def giudizi_negativi(self):
"""
Restituisce il numero di giudizi negativi associati all'oggetto.
"""
return self._giudizi(self, False) | CroceRossaItaliana/jorvik | [
29,
20,
29,
131,
1424890427
] |
def giudizio_cerca(self, autore):
"""
Cerca il giudizio di un autore sull'oggetto. Se non presente,
ritorna None.
"""
g = self.giudizi.filter(autore=autore)[:1]
if g:
return g
return None | CroceRossaItaliana/jorvik | [
29,
20,
29,
131,
1424890427
] |
def isFolder (idx=currentItemPos()):
if DETVIDEXT and isVidExt(getTitle(idx)) : return False
return True if getLi('Property(IsPlayable)',idx) in ('false', Empty) and not getFname(idx) else False | Taifxx/xxtrep | [
9,
6,
9,
4,
1460037342
] |
def isVidExt(name):
for itm in TAG_PAR_VIDEOSEXT:
if name.endswith(itm) : return True
return False | Taifxx/xxtrep | [
9,
6,
9,
4,
1460037342
] |
def getJsp(dirPath, srcName):
_itmList = eval(xbmc.executeJSONRPC(_listdircmd % (dirPath)))['result']['files']
_jsp = struct() | Taifxx/xxtrep | [
9,
6,
9,
4,
1460037342
] |
def jsp_isFolder(jsp, idx):
if jsp.itmList[idx]['filetype'] != 'folder' : return False
return True | Taifxx/xxtrep | [
9,
6,
9,
4,
1460037342
] |
def __init__(self, dirPath=Empty, srcName=Empty):
if not dirPath : self.norm_init()
else : self.jsp_init (dirPath, srcName) | Taifxx/xxtrep | [
9,
6,
9,
4,
1460037342
] |
def jsp_init(self, dirPath, srcName): | Taifxx/xxtrep | [
9,
6,
9,
4,
1460037342
] |
def norm_init(self): | Taifxx/xxtrep | [
9,
6,
9,
4,
1460037342
] |
def setmanually(self, manlist):
self.vidListItems = [itm for idx, itm in enumerate(self.vidListItemsRaw) if idx in manlist] | Taifxx/xxtrep | [
9,
6,
9,
4,
1460037342
] |
def reverse(self):
self.vidListItems.reverse()
self.vidListItemsRaw.reverse() | Taifxx/xxtrep | [
9,
6,
9,
4,
1460037342
] |
def getOnlyNexts(self):
nexts = False
retList = []
for itm in self.vidListItems:
if itm[0] == self.vidCurr : nexts = True; continue
if not nexts : continue
retList.append(itm[1]) | Taifxx/xxtrep | [
9,
6,
9,
4,
1460037342
] |
def __init__(self, api_object: ApiCaller, action_name: str):
self.api_object = api_object
self.action_name = action_name
self.help_description = self.help_description.format(self.api_object.endpoint_url) | PayloadSecurity/VxAPI | [
193,
55,
193,
3,
1489176142
] |
def build_argument_builder(self, child_parser):
return DefaultCliArguments(child_parser) | PayloadSecurity/VxAPI | [
193,
55,
193,
3,
1489176142
] |
def attach_args(self, args):
self.given_args = args.copy()
args_to_send = args.copy()
for arg_to_remove in self.args_to_prevent_from_being_send:
if arg_to_remove in args_to_send:
del args_to_send[arg_to_remove]
if 'output' in args:
self.cli_output_folder = args['output']
del args_to_send['output']
args_to_send = {k: v for k, v in args_to_send.items() if v not in [None, '']} # Removing some 'empty' elements from dictionary
if 'file' in args:
del args_to_send['file'] # attaching file is handled by separated method
if self.api_object.request_method_name == ApiCaller.CONST_REQUEST_METHOD_GET:
self.api_object.attach_params(args_to_send)
else: # POST
self.api_object.attach_data(args_to_send) | PayloadSecurity/VxAPI | [
193,
55,
193,
3,
1489176142
] |
def get_colored_response_status_code(self):
response_code = self.api_object.get_response_status_code()
return Color.success(response_code) if self.api_object.if_request_success() is True else Color.error(response_code) | PayloadSecurity/VxAPI | [
193,
55,
193,
3,
1489176142
] |
def get_result_msg(self):
if self.api_object.api_response.headers['Content-Type'] == 'text/html':
raise ResponseTextContentTypeError('Can\'t print result, since it\'s \'text/html\' instead of expected content type with \'{}\' on board.'.format(self.api_object.api_expected_data_type))
if self.api_object.api_expected_data_type == ApiCaller.CONST_EXPECTED_DATA_TYPE_JSON:
return self.result_msg_for_json.format(CliJsonFormatter.format_to_pretty_string(self.api_object.get_response_json()))
elif self.api_object.api_expected_data_type == ApiCaller.CONST_EXPECTED_DATA_TYPE_FILE:
if self.api_object.if_request_success() is True:
return self.get_result_msg_for_files()
else:
error_msg = 'Error has occurred and your files were not saved.'
if self.given_args['verbose'] is False:
error_msg += ' To get more information, please run command in verbose mode. (add \'-v\')'
return error_msg | PayloadSecurity/VxAPI | [
193,
55,
193,
3,
1489176142
] |
def get_result_msg_for_files(self):
return self.result_msg_for_files.format(self.get_processed_output_path()) | PayloadSecurity/VxAPI | [
193,
55,
193,
3,
1489176142
] |
def get_date_string(self):
now = datetime.datetime.now()
return '{}_{}_{}_{}_{}_{}'.format(now.year, now.month, now.day, now.hour, now.minute, now.second) | PayloadSecurity/VxAPI | [
193,
55,
193,
3,
1489176142
] |
def get_es_client(silent=False):
"""
Returns the elasticsearch client which uses the configuration file
"""
es_client = Elasticsearch([settings.ELASTIC_SEARCH_HOST],
scheme='http',
port=9200,
http_compress=True)
# test if it works
if not silent and not es_client.cat.health(request_timeout=30):
raise ValueError('Credentials do not work for Elastic search')
return es_client | fako/datascope | [
5,
6,
5,
13,
1382612206
] |
def setup(self):
self.set_name('DummySnuffling') | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def setUpClass(cls):
'''
Create a reusable snuffler instance for all tests cases.
'''
super(GUITest, cls).setUpClass()
if no_gui: # nosetests runs this even when class is has @skip
return
from pyrocko.gui import snuffler as sm
cls.snuffler = sm.get_snuffler_instance()
fpath = common.test_data_file('test2.mseed')
p = make_pile(fpath, show_progress=False)
cls.win = SnufflerWindow(pile=p, instant_close=True)
cls.pile_viewer = cls.win.pile_viewer
cls.viewer = cls.win.pile_viewer.viewer
pv = cls.pile_viewer
cls.main_control_defaults = dict(
highpass_control=pv.highpass_control.get_value(),
lowpass_control=pv.lowpass_control.get_value(),
gain_control=pv.gain_control.get_value(),
rot_control=pv.rot_control.get_value()) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def tearDownClass(cls):
'''
Quit snuffler.
'''
if no_gui: # nosetests runs this even when class is has @skip
return
QTest.keyPress(cls.pile_viewer, 'q') | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def tearDown(self):
self.clear_all_markers()
for tempfn in self.tempfiles:
os.remove(tempfn)
self.viewer.set_time_range(*self.initial_trange) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def write_to_input_line(self, text):
'''emulate writing to inputline and press return'''
pv = self.pile_viewer
il = pv.inputline
QTest.keyPress(pv, ':')
QTest.keyClicks(il, text)
QTest.keyPress(il, Qt.Key_Return) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def trigger_menu_item(self, qmenu, action_text, dialog=False):
''' trigger a QMenu QAction with action_text. '''
for iaction, action in enumerate(qmenu.actions()):
if action.text() == action_text:
if dialog:
def closeDialog():
dlg = self.snuffler.activeModalWidget()
QTest.keyClick(dlg, Qt.Key_Escape)
qc.QTimer.singleShot(150, closeDialog)
action.trigger()
break | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def drag_slider(self, slider):
''' Click *slider*, drag from one side to the other, release mouse
button repeat to restore inital state'''
position = self.get_slider_position(slider)
QTest.mouseMove(slider, pos=position.topLeft())
QTest.mousePress(slider, Qt.LeftButton)
QTest.mouseMove(slider, pos=position.bottomRight())
QTest.mouseRelease(slider, Qt.LeftButton)
QTest.mousePress(slider, Qt.LeftButton)
QTest.mouseMove(slider, pos=position.topLeft())
QTest.mouseRelease(slider, Qt.LeftButton) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def test_main_control_sliders(self):
self.drag_slider(self.pile_viewer.highpass_control.slider)
self.drag_slider(self.pile_viewer.lowpass_control.slider)
self.drag_slider(self.pile_viewer.gain_control.slider)
self.drag_slider(self.pile_viewer.rot_control.slider) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def test_drawing_optimization(self):
n = 505
lats = num.random.uniform(-90., 90., n)
lons = num.random.uniform(-180., 180., n)
events = []
for i, (lat, lon) in enumerate(zip(lats, lons)):
events.append(
model.Event(time=i, lat=lat, lon=lon, name='XXXX%s' % i))
self.viewer.add_event(events[-1])
assert len(self.viewer.markers) == 1
self.viewer.add_events(events)
assert len(self.viewer.markers) == n + 1
self.viewer.set_time_range(-500., 5000)
self.viewer.set_time_range(0., None)
self.viewer.set_time_range(None, 0.) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def test_save_image(self):
tempfn_svg = self.get_tempfile() + '.svg'
self.viewer.savesvg(fn=tempfn_svg)
tempfn_png = self.get_tempfile() + '.png'
self.viewer.savesvg(fn=tempfn_png) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def test_add_remove_stations(self):
n = 10
lats = num.random.uniform(-90., 90., n)
lons = num.random.uniform(-180., 180., n)
stations = [
model.station.Station(network=str(i), station=str(i),
lat=lat, lon=lon) for i, (lat, lon) in
enumerate(zip(lats, lons))
]
tempfn = self.get_tempfile()
model.station.dump_stations(stations, tempfn)
self.viewer.open_stations(fns=[tempfn])
last = stations[-1]
self.assertTrue(self.viewer.has_station(last))
self.viewer.get_station((last.network, last.station)) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def test_load_waveforms(self):
self.viewer.load('data', regex=r'\w+.mseed')
self.assertFalse(self.viewer.get_pile().is_empty()) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def test_event_marker(self):
pv = self.pile_viewer
self.add_one_pick()
# select all markers
QTest.keyPress(pv, 'a', Qt.ShiftModifier, 100)
# convert to EventMarker
QTest.keyPress(pv, 'e')
QTest.keyPress(pv, 'd')
for m in pv.viewer.get_markers():
self.assertTrue(isinstance(m, gui_util.EventMarker)) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def test_actions(self):
# Click through many menu option combinations that do not require
# further interaction. Activate options in pairs of two.
pv = self.pile_viewer
tinit = pv.viewer.tmin
tinitlen = pv.viewer.tmax - pv.viewer.tmin
non_dialog_actions = [
'Indivdual Scale',
'Common Scale',
'Common Scale per Station',
'Common Scale per Component',
'Scaling based on Minimum and Maximum',
'Scaling based on Mean +- 2 x Std. Deviation',
'Scaling based on Mean +- 4 x Std. Deviation',
'Sort by Names',
'Sort by Distance',
'Sort by Azimuth',
'Sort by Distance in 12 Azimuthal Blocks',
'Sort by Backazimuth',
'3D distances',
'Subsort by Network, Station, Location, Channel',
'Subsort by Network, Station, Channel, Location',
'Subsort by Station, Network, Channel, Location',
'Subsort by Location, Network, Station, Channel',
'Subsort by Channel, Network, Station, Location',
'Subsort by Network, Station, Channel (Grouped by Location)',
'Subsort by Station, Network, Channel (Grouped by Location)',
]
dialog_actions = [
'Open waveform files...',
'Open waveform directory...',
'Open station files...',
'Save markers...',
'Save selected markers...',
'Open marker file...',
'Open event file...',
'Save as SVG|PNG',
]
options = [
'Antialiasing',
'Liberal Fetch Optimization',
'Clip Traces',
'Show Boxes',
'Color Traces',
'Show Scale Ranges',
'Show Scale Axes',
'Show Zero Lines',
'Fix Scale Ranges',
'Allow Downsampling',
'Allow Degapping',
'FFT Filtering',
'Bandpass is Lowpass + Highpass',
'Watch Files',
]
# create an event marker and activate it
self.add_one_pick()
keys = list('mAhefrRh+-fgc?')
keys.extend([Qt.Key_PageUp, Qt.Key_PageDown])
def fire_key(x):
QTest.keyPress(self.pile_viewer, key)
for key in keys:
QTest.qWait(100)
fire_key(key)
event = model.Event()
markers = pv.viewer.get_markers()
self.assertEqual(len(markers), 1)
markers[0]._event = event
pv.viewer.set_active_event(event)
pv.viewer.set_event_marker_as_origin()
right_click_menu = self.viewer.menu
for action_text in dialog_actions:
self.trigger_menu_item(right_click_menu, action_text, dialog=True)
for action_text in non_dialog_actions:
for oa in options:
for ob in options:
self.trigger_menu_item(right_click_menu, action_text)
self.trigger_menu_item(right_click_menu, oa)
self.trigger_menu_item(right_click_menu, ob)
options.remove(oa)
self.viewer.go_to_event_by_name(event.name)
self.viewer.go_to_time(tinit, tinitlen) | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def test_frames(self):
frame_snuffling = DummySnuffling()
self.viewer.add_snuffling(frame_snuffling)
frame_snuffling.call()
# close three opened frames
QTest.keyPress(self.pile_viewer, 'd')
QTest.keyPress(self.pile_viewer, 'd')
QTest.keyPress(self.pile_viewer, 'd') | pyrocko/pyrocko | [
164,
75,
164,
52,
1268295595
] |
def __init__(self,age):
self.age = age | tuxfux-hlp-notes/python-batches | [
5,
15,
5,
2,
1481601578
] |
def __init__(self, in_queue, out_queue, name, description = None):
super(APModule, self).__init__()
signal.signal(signal.SIGINT, self.exit_gracefully)
signal.signal(signal.SIGTERM, self.exit_gracefully)
self.daemon = True
self.config_list= [] # overwrite this list
self.config_changed = False
self.config = read_config()
self.start_time = time.time()
self.last_ping = None
self.needs_unloading = Event()
self.lock = threading.Lock()
self.in_queue = in_queue
self.out_queue = out_queue
self.name = name
self.ping = PeriodicEvent(frequency = 1.0/3.0, event = self.send_ping)
self.in_queue_thread = threading.Thread(target=self.in_queue_handling,
args = (self.lock,))
self.in_queue_thread.daemon = True
setproctitle.setproctitle(self.name)
if description is None:
self.description = "APSync {0} process".format(self.name)
else:
self.description = description | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def update_config(self, config_list = []):
if len(config_list):
self.config_list = config_list
for (var_name, var_default) in self.config_list:
self.set_config(var_name, var_default) | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def send_ping(self):
self.out_queue.put_nowait(ping(self.name, self.pid)) | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def exit_gracefully(self, signum, frame):
self.unload() | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def unload(self):
print self.name, 'called unload'
self.unload_callback()
self.needs_unloading.set() | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def unload_callback(self):
''' overload to perform any module specific cleanup'''
pass | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def run(self):
if self.in_queue_thread is not None:
self.in_queue_thread.start()
while not self.needs_unloading.is_set():
try:
self.main()
except:
print ("FATAL: module ({0}) exited while multiprocessing".format(self.name))
traceback.print_exc()
# TODO: logging here
print self.name, 'main finished' | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def main(self):
pass | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def in_queue_handling(self, lock=None):
while not self.needs_unloading.is_set():
(inputready,outputready,exceptready) = select.select([self.in_queue._reader],[],[],0.1)
for s in inputready:
while not self.in_queue.empty():
# drain the queue
data = self.in_queue.get_nowait()
if isinstance(data, Unload):
self.unload()
else:
# do something useful with the data...
self.process_in_queue_data(data)
self.ping.trigger() | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def process_in_queue_data(self, data):
pass | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def log(self, message, level = 'INFO'): | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def set_config(self, var_name, var_default):
new_val = self.config.get(var_name, var_default)
try:
cur_val = self.config[var_name]
if new_val != cur_val:
self.config_changed = True
except:
self.config_changed = True | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def __init__(self, name):
self.ack = False | SamuelDudley/APSyncWeb | [
1,
3,
1,
4,
1494949233
] |
def __init__(self, integration_widget, dioptas_model):
"""
:param integration_widget: Reference to an IntegrationWidget
:param dioptas_model: reference to DioptasModel object
:type integration_widget: IntegrationWidget
:type dioptas_model: DioptasModel
"""
self.model = dioptas_model
self.phase_model = self.model.phase_model
self.integration_widget = integration_widget
self.cake_view_widget = integration_widget.integration_image_widget.cake_view # type: IntegrationImgWidget
self.connect() | Dioptas/Dioptas | [
44,
25,
44,
14,
1421345772
] |
def get_phase_position_and_intensities(self, ind, clip=True):
"""
Obtains the positions and intensities for lines of a phase with an index ind within the cake view.
No clipping is used for the first call to add the CakePhasePlot to the ImgWidget. Subsequent calls are used with
clipping. Thus, only lines within the cake_tth are returned. The visibility of each line is then estimated in
the ImgWidget based on the length of the clipped and not clipped lists.
:param ind: the index of the phase
:param clip: whether or not the lists should be clipped. Clipped means that lines which have positions larger
than the
:return: line_positions, line_intensities
"""
if self.model.cake_tth is None:
cake_tth = self.model.calibration_model.tth
else:
cake_tth = self.model.cake_tth
reflections_tth = self.phase_model.get_phase_line_positions(ind, 'tth',
self.model.calibration_model.wavelength * 1e10)
reflections_intensities = [reflex[1] for reflex in self.phase_model.reflections[ind]]
cake_line_positions = []
cake_line_intensities = []
for ind, tth in enumerate(reflections_tth):
pos_ind = get_partial_index(cake_tth, tth)
if pos_ind is not None:
cake_line_positions.append(pos_ind + 0.5)
cake_line_intensities.append(reflections_intensities[ind])
elif clip is False:
cake_line_positions.append(0)
cake_line_intensities.append(reflections_intensities[ind])
return cake_line_positions, cake_line_intensities | Dioptas/Dioptas | [
44,
25,
44,
14,
1421345772
] |
def update_phase_lines(self, ind):
cake_line_positions, cake_line_intensities = self.get_phase_position_and_intensities(ind)
self.cake_view_widget.update_phase_intensities(ind, cake_line_positions, cake_line_intensities) | Dioptas/Dioptas | [
44,
25,
44,
14,
1421345772
] |
def update_phase_visible(self, ind):
if self.phase_model.phase_visible[ind] and self.integration_widget.img_mode == 'Cake' and \
self.integration_widget.img_phases_btn.isChecked():
self.cake_view_widget.show_cake_phase(ind)
else:
self.cake_view_widget.hide_cake_phase(ind) | Dioptas/Dioptas | [
44,
25,
44,
14,
1421345772
] |
def make_book_to_index(bible):
btoi = {}
for i, book in enumerate(bible):
btoi[book['name'].lower()] = i
return btoi | sentriz/steely | [
21,
14,
21,
6,
1498783471
] |
def plugin_setup():
global bible, book_to_index
try:
bible = json.loads(open(BIBLE_FILE, encoding='utf-8-sig').read())
book_to_index = make_book_to_index(bible)
return
except BaseException as e:
pass
# We've tried nothing and we're all out of ideas, download a new bible.
try:
bible = json.loads(
requests.get(BIBLE_URL).content.decode('utf-8-sig'))
except BaseException as e:
return "Error loading bible: " + str(e)
book_to_index = make_book_to_index(bible)
with open(BIBLE_FILE, 'w') as f:
json.dump(bible, f) | sentriz/steely | [
21,
14,
21,
6,
1498783471
] |
def help_command(bot, message: SteelyMessage, **kwargs):
bot.sendMessage(
HELP_STR,
thread_id=message.thread_id, thread_type=message.thread_type) | sentriz/steely | [
21,
14,
21,
6,
1498783471
] |
def get_quote(book, chapter, verse):
return "{}\n - {} {}:{}".format(
bible[book]["chapters"][chapter][verse],
bible[book]["name"], chapter + 1, verse + 1) | sentriz/steely | [
21,
14,
21,
6,
1498783471
] |
def __init__(self, tb):
_threading.Thread.__init__(self)
self.setDaemon(1)
self.tb = tb
self.done = False
self.start() | bistromath/gr-smartnet | [
44,
22,
44,
4,
1301549389
] |
def __init__(self, options, queue):
gr.top_block.__init__(self)
if options.filename is not None:
self.fs = gr.file_source(gr.sizeof_gr_complex, options.filename)
self.rate = options.rate
else:
self.u = uhd.usrp_source(options.addr,
io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1)
if options.subdev is not None:
self.u.set_subdev_spec(options.subdev, 0) | bistromath/gr-smartnet | [
44,
22,
44,
4,
1301549389
] |