IntroductionCredit: Gustavo Niemeyer, Facundo Batista Today, last weekend, next year. These terms sound so common. You have probably wondered, at least once, about how deeply our lives are involved in the very idea of time. The concept of time surrounds us, and, as a consequence, it's also present in the vast majority of software projects. Even very simple programs may have to deal with timestamps, delays, timeouts, speed gauges, calendars, and so on. As befits a general-purpose language that is proud to come with "batteries included," Python's standard library offers solid support for these application needs, and more support yet comes from third-party modules and packages. Computing tasks involving money are another interesting topic that catches our attention because it's so closely related to our daily lives. Python 2.4 introduced support for decimal numbers (and you can retrofit that support into 2.3, see http://www.taniquetil.com.ar/facundo/bdvfiles/get_decimal.html), making Python a good option even for computations where you must avoid using binary floats, as ones involving money so often are. This chapter covers exactly these two topics, money and time. According to the old saying, maybe we should claim the chapter is really about a single topic, since after all, as everybody knowstime is money! The time ModulePython Standard Library's time module lets Python applications access a good portion of the time-related functionality offered by the platform Python is running on. Your platform's documentation for the equivalent functions in the C library will therefore be useful, and some peculiarities of different platforms will affect Python as well. One of the most used functions from module time is the one that obtains the current timetime.time. This function's return value may be a little cryptic for the uninitiated: it's a floating-point number that corresponds to the number of seconds passed since a fixed instant called the epoch, which may change depending on your platform but is usually midnight of January 1, 1970. To check which epoch your platform uses, try, at any Python interactive interpreter prompt: >>> import time >>> print time.asctime(time.gmtime(0)) Notice we're passing 0 (meaning 0 seconds after the epoch) to the time.gmtime function. time.gmtime converts any timestamp (in seconds since the epoch) into a tuple that represents that precise instant of time in human terms, without applying any kind of time zone conversion (GMT stands for "Greenwich mean time", an old but colorful way to refer to what is now known as UTC, for "Coordinated Universal Time"). You can also pass a timestamp (in seconds since the epoch) to time.localtime, which applies the current local notion of time zone. It's important to understand the difference, since, if you have a timestamp that is already offset to represent a local time, passing it to the time.localtime function will not yield the expected resultunless you're so lucky that your local time zone happens to coincide with the UTC time zone, of course! Here is a way to unpack a tuple representing the current local time: year, month, mday, hour, minute, second, wday, yday = time.localtime( ) While valid, this code is not elegant, and it would certainly not be practical to use it often. This kind of construct may be completely avoided, since the tuples returned by the time functions let you access their elements via meaningful attribute names. Obtaining the current month then becomes a simple and elegant expression: time.localtime( ).tm_mon Note that we omitted passing any argument to localtime. When we call localtime, gmtime, or asctime without an argument, each of them conveniently defaults to using the current time. Two very useful functions in module time are strftime, which lets you build a string from a time tuple, and strptime, which goes the other way, parsing a string and producing a time tuple. Each of these two functions accepts a format string that lets you specify exactly what you want in the resulting string (or, respectively, what you expect from the string you're parsing) in excruciating detail. For all the formatting specifications that you can use in the format strings you pass to these functions, see http://docs.python.org/lib/module-time.html. One last important function in module time is the time.sleep function, which lets you introduce delays in Python programs. Even though this function's POSIX counterpart accepts only an integer parameter, the Python equivalent supports a float and allows sub-second delays to be achieved. For instance: for i in range(10): time.sleep(0.5) print "Tick!" This snippet will take about 5 seconds to execute, emitting Tick! approximately twice per second. Time and Date ObjectsWhile module time is quite useful, the Python Standard Library also includes the datetime module, which supplies types that provide better abstractions for the concepts of dates and timesnamely, the types time, date, and datetime. Constructing instances of those types is quite elegant: today = datetime.date.today( ) birthday = datetime.date(1977, 5, 4) #May 4 currenttime = datetime.datetime.now( ).time( ) lunchtime = datetime.time(12, 00) now = datetime.datetime.now( ) epoch = datetime.datetime(1970, 1, 1) meeting = datetime.datetime(2005, 8, 3, 15, 30) Further, as you'd expect, instances of these types offer comfortable information access and useful operations through their attributes and methods. The following statements create an instance of the date type, representing the current day, then obtain the same date in the next year, and finally print the result in a dotted format: today = datetime.date.today( ) next_year = today.replace(year=today.year+1).strftime("%Y.%m.%d") print next_year Notice how the year was incremented, using the replace method. Assigning to the attributes of date and time instances may sound tempting, but these instances are immutable (which is a good thing, because it means we can use the instances as members in a set, or keys in a dictionary!), so new instances must be created instead of changing existing ones. Module datetime also provides basic support for time deltas (differences between instants of time; you can think of them as basically meaning durations in time), through the timedelta type. This type lets you change a given date by incrementing or decrementing the date by a given time slice, and it is also the result of taking the difference between times or dates. >>> import datetime >>> NewYearsDay = datetime.date(2005, 01, 01) >>> NewYearsEve = datetime.date(2004, 12, 31) >>> oneday = NewYearsDay - NewYearsEve >>> print oneday 1 day, 0:00:00 >>> A timedelta instance is internally represented by days, seconds, and microseconds, but you can construct timedelta instances by passing any of these arguments and also other multipliers, like minutes, hours and weeks. Support for other kinds of deltas, like months, and years, is not availableon purpose, since their meanings, and operation results, are debatable. (This feature is, however, offered by the third-party dateutil packagesee https://moin.conectiva.com.br/DateUtil.) datetime can be described as a prudent or cautious design. The decision of not implementing doubtful tasks, and tasks that may need many different implementations in different systems, reflects the strategy used to develop all of the module. This way, the module offers good interfaces for most use cases, and, even more importantly, a strong and coherent base for third-party modules to build upon. Another area where this cautious design strategy for datetime shows starkly is the module's time zone support. Even though datetime offers nice ways to query and set time zone information, they're not really useful without an external source to provide nonabstract subclasses of the tzinfo type. At least two third-party packages provide time zone support for datetime: dateutil, mentioned previously, and pyTZ, available at http://sourceforge.net/projects/pytz/. Decimaldecimal is a Python Standard Library module, new in Python 2.4, which finally brings decimal arithmetic to Python. Thanks to decimal, we now have a decimal numeric data type, with bounded precision and floating point. Let's look at each of these three little phrases in more detail:
Such a data type has many uses (the big use case is as the basis for money computations), particularly because decimal.Decimal offers many other advantages over standard binary float. The main advantage is that all of the decimal numbers that the user can enter (which is to say, all the decimal numbers with a finite number of digits) can be represented exactly (in contrast, some of those numbers do not have an exact representation in binary floating point): >>> import decimal >>> 1.1 1.1000000000000001 >>> 2.3 2.2999999999999998 >>> decimal.Decimal("1.1") Decimal("1.1") >>> decimal.Decimal("2.3") Decimal("2.3") The exactness of the representation carries over into arithmetic. In binary floating point, for example: >>> 0.1 + 0.1 + 0.1 - 0.3 5.5511151231257827e-17 Such differences are very close to zero, and yet they prevent reliable equality testing; moreover, even tiny differences can accumulate. For this reason, decimal should be preferred to binary floats in accounting applications that have strict equality requirements: >>> d1 = decimal.Decimal("0.1") >>> d3 = decimal.Decimal("0.3") >>> d1 + d1 + d1 - d3 Decimal("0.0") decimal.Decimal instances can be constructed from integers, strings, or tuples. To create a decimal.Decimal from a float, first convert the float to a string. This necessary step serves as an explicit reminder of the details of the conversion, including representation error. Decimal numbers include special values such as NaN (which stands for "not a number"), positive and negative Infinity, and -0. Once constructed, a decimal.Decimal object is immutable, just like any other number in Python. The decimal module essentially implements the rules of arithmetic that are taught in school. Up to a given working precision, exact, unrounded results are given whenever possible: >>> 0.9 / 10 0.089999999999999997 >>> decimal.Decimal("0.9") / decimal.Decimal(10) Decimal("0.09") Where the number of digits in a result exceeds the working precision, the number is rounded according to the current rounding method. Several rounding methods are available; the default is round-half-even. The decimal module incorporates the notion of significant digits, so that, for example, 1.30+1.20 is 2.50. The trailing zero is kept to indicate significance. This is the usual representation for monetary applications. For multiplication, the "schoolbook" approach uses all the figures in the multiplicands: >>> decimal.Decimal("1.3") * decimal.Decimal("1.2") Decimal("1.56") >>> decimal.Decimal("1.30") * decimal.Decimal("1.20") Decimal("1.5600") In addition to the standard numeric properties that decimal objects share with other built-in number types, such as float and int, decimal objects also have several specialized methods. Check the docs for all of the methods, with details and examples. The decimal data type works within a context, where some configuration aspects are set. Each thread has its own current context (having a separate context per thread means that each thread may make changes without interfering with other threads); the current thread's current context is accessed or changed using functions getcontext and setcontext from the decimal module. Unlike hardware-based binary floating point, the precision of the decimal module can be set by users (defaulting to 28 places). It can be set to be as large as needed for a given problem: >>> decimal.getcontext( ).prec = 6 # set the precision to 6... >>> decimal.Decimal(1) / decimal.Decimal(7) Decimal("0.142857") >>> decimal.getcontext( ).prec = 60 # ...and to 60 digits >>> decimal.Decimal(1) / decimal.Decimal(7) Decimal("0.142857142857142857142857142857142857142857142857142857142857") Not everything in decimal can be as simple and elementary as shown so far, of course. Essentially, decimal implements the standards for general decimal arithmetic which you can study in detail at http://www2.hursley.ibm.com/decimal/. In particular, this means that decimal supports the concept of signals. Signals represent abnormal conditions arising from computations (e.g., 1/0, 0/0, Infinity/Infinity). Depending on the needs of each specific application, signals may be ignored, considered as informational, or treated as exceptions. For each signal, there is a flag and a trap enabler. When a signal is encountered, its flag is incremented from zero, and then, if the trap enabler is set to one, an exception is raised. This gives programmers a great deal of power and flexibility in configuring decimal to meet their exact needs. Given all of these advantages for decimal, why would someone want to stick with float? Indeed, is there any reason why Python (like just about every other widespread language, with Cobol and Rexx the two major exceptions that easily come to mind) originally adopted floating-point binary numbers as its default (or only) noninteger data type? Of coursemany reasons can be provided, and they're all spelled speed! Consider: $ python -mtimeit -s'from decimal import Decimal as D' 'D("1.2")+D("3.4")' 10000 loops, best of 3: 191 usec per loop $ python -mtimeit -s'from decimal import Decimal as D' '1.2+3.4' 1000000 loops, best of 3: 0.339 usec per loop This basically translates to: on this machine (an old Athlon 1.2 GHz PC running Linux), Python can perform almost 3 million sums per second on floats (using the PC's arithmetic hardware), but only a bit more than 5 thousand sums per second on Decimals (all done in software and with all the niceties shown previously). Essentially, if your application must sum many tens of millions of noninteger numbers, you had better stick with float! When an average machine was a thousand times slower than it is today (and it wasn't all that long ago!), such limitations hit even applications doing relatively small amounts of computation, if the applications ran on reasonably cheap machines (again, we see time and money both playing a role!). Rexx and Cobol were born on mainframes that were not quite as fast as today's cheapest PCs but thousands of times more expensive. Purchasers of such mainframes could afford nice and friendly decimal arithmetic, but most other languages, born on more reasonably priced machines (or meant for computationally intensive tasks), just couldn't. Fortunately, relatively few applications actually need to perform so much arithmetic on non-integers as to give any observable performance problems on today's typical machines. Thus, today, most applications can actually take advantage of decimal's many beneficial aspects, including applications that must continue to use Python 2.3, even though decimal is in the Python Standard Library only since version 2.4. To learn how you can easily integrate decimal into Python 2.3, see http://www.taniquetil.com.ar/facundo/bdvfiles/get_decimal.html. |


Preparation time
less than 30 mins
Cooking time
over 2 hours
Serves
Serves 4
For the sugar syrup, place all the syrup ingredients into a pan and bring to the boil, stirring occasionally with a wooden spoon. Boil for 2-3 minutes, skimming the surface if necessary. Pass the syrup through a fine sieve and set aside until completely cooled.
For the Italian meringue, place the sugar and water into a pan and slowly bring to the boil until the syrup reaches 110C/230F (use a sugar thermometer to check the temperature).
At this stage, place the egg whites into a bowl and whisk until firm peaks form when the whisk is removed.
As soon as the sugar reaches 121C/250F, remove the pan from the heat. Immediately resume whisking the egg whites. While whisking, gradually pour the sugar and water mixture into the egg whites in a steady stream, keeping it clear of the beaters. Continue whisking for 4-5 minutes, until the meringue is tepid.
For the passionfruit delice, blend the passion fruit pulp and the sugar syrup in a food processor until smooth. Strain the mixture through a fine sieve.
Place the passion fruit purée into a pan, add the powdered milk and vanilla pod and bring to the boil.
Place the egg yolks and sugar into a bowl and whisk until the mixture forms a ribbon when the whisk is removed (this is called the ribbon stage). Pour the passion fruit mixture onto the egg mixture, whisking continuously, then pour this custard mixture back into the pan. Heat gently, stirring continuously with a spatula, until the custard is thick enough to coat the back of the spatula (do not allow the mixture to boil).
Remove the pan from the heat and stir the drained gelatine into the custard. Strain the custard through a conical sieve and set aside to cool. Stir occasionally to prevent a skin forming.
When the custard is lukewarm, gently fold in half of the Italian meringue (the remaining meringue can be used in another recipe). Stir in the passion fruit liqueur, and then fold in the whipped double cream. (You must now assemble the dessert immediately, before the gelatine causes the mixture to set.)
Place the sponge flan bases onto a chopping board. Mix together 50ml/2fl oz of the sugar syrup and one tablespoon of the reserved passion fruit purée and brush this mixture over the sponge. Place a 25cm/10in flan ring (6cm/2½in deep) onto the sponge and cut out a circle to form the base (discard the excess sponge).
Fill the flan ring with the passion fruit custard mixture, leaving a small gap at the top, and carefully smooth the surface with a palette knife. Transfer to the freezer and chill for several hours.
For the glaze, place the sugar syrup and the passion fruit pulp into a pan and heat gently, then remove from the heat, stir in the drained gelatine and set aside to cool. Once cool, remove the delice from the freezer and spread the glaze over the top of the passion fruit filling. Transfer to the fridge to chill again before serving.
To serve, remove the tart ring by heating the outside of the ring with a blowtorch for a few seconds, then slide the ring upwards, rotating it slightly.
Place a slice of delice onto a serving plate and garnish with redcurrants, blackberries, and passionfruit pulp.


Thank you for your interest in contributing to Goldstone Server ("We" or "Us").
The purpose of this contributor agreement ("Agreement") is to clarify and document the rights granted by contributors to Us. To make this document effective, please follow the instructions at http://www.solinea.com/goldstone/cla.html.
"You" means the Individual Copyright owner who submits a Contribution to Us. If You are an employee and submit the Contribution as part of your employment, You have had Your employer approve this Agreement or sign the Entity version of this document.
"Contribution" means any original work of authorship (software and/or documentation) including any modifications or additions to an existing work, Submitted by You to Us, in which You own the Copyright. If You do not own the Copyright in the entire work of authorship, please contact Us at<EMAIL_ADDRESS>"Copyright" means all rights protecting works of authorship owned or controlled by You, including copyright, moral and neighboring rights, as appropriate, for the full term of their existence including any extensions by You.
"Material" means the software or documentation made available by Us to third parties. When this Agreement covers more than one software project, the Material means the software or documentation to which the Contribution was Submitted. After You Submit the Contribution, it may be included in the Material.
"Submit" means any form of physical, electronic, or written communication sent to Us, including but not limited to electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, Us, but excluding communication that is conspicuously marked or otherwise designated in writing by You as "Not a Contribution."
"Submission Date" means the date You Submit a Contribution to Us.
"Documentation" means any non-software portion of a Contribution.
2.1 Copyright License to Us
Subject to the terms and conditions of this Agreement, You hereby grant to Us a worldwide, royalty-free, NON-exclusive, perpetual and irrevocable license, with the right to transfer an unlimited number of non-exclusive licenses or to grant sublicenses to third parties, under the Copyright covering the Contribution to use the Contribution by all means, including, but not limited to:
2.2 Moral Rights remain unaffected to the extent they are recognized and not waivable by applicable law. Notwithstanding, You may add your name in the header of the source code files of Your Contribution and We will respect this attribution when using Your Contribution.
3.1 Pledge of Identified Patents
Whereas You are aware of certain of Your own patents, which You desire to identify and disclose as the following patents and patent applications ("Pledged Patents"):
Number or Application Number
Country
You hereby pledge to all developers, distributors and users of the Contribution or the Material to which this Agreement applies ("Pledge Recipient") that You and your Affiliates will not bring a lawsuit or other legal proceeding against a Pledge Recipient for patent infringement under any Pledged Patents based on the Pledge Recipient's making, having made, using, selling, offering for sale, importing or otherwise transferring the Contribution or the Material. You will require any person or entity to whom You sell or transfer any of the Pledged Patents to agree, in writing, to abide by the pledge and to place a similar requirement on any subsequent transferees to do the same.
3.2 Revocation of Patent Pledge
You reserve the right to revoke the patent pledge stated in section 3.1, as if it never existed with regard to any Pledge Recipient, who files a lawsuit or other legal proceedings for patent infringement or who has a direct financial interest in such a lawsuit or other legal proceedings against You or your Affiliates.
We agree to license the Contribution only under the terms of the license or licenses that We are using on the Submission Date for the Material (including any rights to adopt any future version of a license).
In addition, We may use the following licenses for Documentation in the Contribution: CC-BY-SA-4.0 (including any right to adopt any future version of a license).
THE CONTRIBUTION IS PROVIDED "AS IS".
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT WILL YOU OR US BE LIABLE FOR ANY LOSS OF PROFITS, LOSS OF ANTICIPATED SAVINGS, LOSS OF DATA, INDIRECT, SPECIAL, INCIDENTAL, CONSEQUENTIAL AND EXEMPLARY DAMAGES ARISING OUT OF THIS AGREEMENT REGARDLESS OF THE LEGAL OR EQUITABLE THEORY (CONTRACT, TORT OR OTHERWISE) UPON WHICH THE CLAIM IS BASED.
IF THE DISCLAIMER AND DAMAGE WAIVER MENTIONED IN SECTION 5 AND SECTION 6 CANNOT BE GIVEN LEGAL EFFECT UNDER APPLICABLE LOCAL LAW, REVIEWING COURTS SHALL APPLY LOCAL LAW THAT MOST CLOSELY APPROXIMATES AN ABSOLUTE WAIVER OF ALL CIVIL LIABILITY IN CONNECTION WITH THE CONTRIBUTION.
8.1 This Agreement shall come into effect upon Your acceptance of the terms and conditions.
8.2 You shall have the right to terminate the Agreement in written form if We do not fulfill the obligations as set forth in Section 4.
8.3 In the event of a termination of this Agreement Sections 5, 6, 7, 8 and 9 shall survive such termination and shall remain in full force thereafter. For the avoidance of doubt, Contributions that are already licensed under a free and open source license at the date of the termination shall remain in full force after the termination of this Agreement.
9.1 This Agreement and all disputes, claims, actions, suits or other proceedings arising out of this agreement or relating in any way to it shall be governed by the laws of United States excluding its private international law provisions.
9.2 This Agreement sets out the entire agreement between You and Us for Your Contributions to Us and overrides all other agreements or understandings.
9.3 If any provision of this Agreement is found void and unenforceable, such provision will be replaced to the extent possible with a provision that comes closest to the meaning of the original provision and that is enforceable. The terms and conditions set forth in this Agreement shall apply notwithstanding any failure of essential purpose of this Agreement or any limited remedy to the maximum extent possible under law.
9.4 You agree to notify Us of any facts or circumstances of which you become aware that would make this Agreement inaccurate in any respect.
| Date: | |
| Name: | |
| Title: | |
| Address: |
| Date: | |
| Name: | |
| Title: | |
| Address: |


Will you insert the floater window in Synergy Adv?
-
Zeno
Hello, I'm a Synergy Classic registered user, I would like to know if you plan to add in Sinergy Advanced the floater with album cover. I think it's one of the best feature of Sinergy Classic...
Thanks a lot!
-
Greg Hurrell
Yes, by the time it hits 1.0 (currently scheduled for August) Advance will do everything that Classic can do. If you want to check out progress via the public preview releases subscribe to the announce mailing list.
https://secure.wincent.com/a/support/lists/
I am rolling out modules one at a time with each new public preview release. Modules like the Floater module, Menu Bar Controls module and Cover Art module will probably be among the last because they are the ones which contain the most radical changes. I'll be releasing the more conservative modules (Scripting, Growl etc) sooner because they've had more testing.
Reply
This topic is now closed.


There is another whole filesystem inside Windows now (if it's installed).
Everything under Linux (except for kernel) enumeration now goes.
Typically in Windows, this is limited to sensitive files since even "root" is a limited account.
Execution of binaries may not be tracked or blocked under wsl (either linux execution or exe execution through Wine)
There could be multiple operating systems
bash_history files
configs
etc


{% extends 'base.html' %} {% block title %}About -{% endblock %} {% block content %}
This is a project that tries to collect WiFi Signatures.
It is based on the paper Passive Taxonomy of Wifi Clients using MLME Frame Contents
There is already a WiFi Signature GitHub-Repositry.
We try to find a way to offer the information in a more user friendly way. You can just query our API.
You can easily add devices through the Django web interface.
You can easily export those devices to a json format.


lenstronomy.ImSim.Numerics package¶
Submodules¶
lenstronomy.ImSim.Numerics.adaptive_numerics module¶
-
class
lenstronomy.ImSim.Numerics.adaptive_numerics.
AdaptiveConvolution
(kernel_super, supersampling_factor, conv_supersample_pixels, supersampling_kernel_size=None, compute_pixels=None, nopython=True, cache=True, parallel=False)[source]¶ Bases:
object
This class performs convolutions of a subset of pixels at higher supersampled resolution Goal: speed up relative to higher resolution FFT when only considering a (small) subset of pixels to be convolved on the higher resolution grid.
strategy: 1. lower resolution convolution over full image with FFT 2. subset of pixels with higher resolution Numba convolution (with smaller kernel) 3. the same subset of pixels with low resolution Numba convolution (with same kernel as step 2) adaptive solution is 1 + 2 - 3
lenstronomy.ImSim.Numerics.convolution module¶
-
class
lenstronomy.ImSim.Numerics.convolution.
PixelKernelConvolution
(kernel, convolution_type='fft_static')[source]¶ Bases:
object
class to compute convolutions for a given pixelized kernel (fft, grid)
-
convolution2d
(image)[source]¶ Parameters: image – 2d array (image) to be convolved Returns: fft convolution
-
copy_transpose
()[source]¶ Returns: copy of the class with kernel set to the transpose of original one
-
-
class
lenstronomy.ImSim.Numerics.convolution.
SubgridKernelConvolution
(kernel_supersampled, supersampling_factor, supersampling_kernel_size=None, convolution_type='fft_static')[source]¶ Bases:
object
class to compute the convolution on a supersampled grid with partial convolution computed on the regular grid
-
class
lenstronomy.ImSim.Numerics.convolution.
MultiGaussianConvolution
(sigma_list, fraction_list, pixel_scale, supersampling_factor=1, supersampling_convolution=False, truncation=2)[source]¶ Bases:
object
class to perform a convolution consisting of multiple 2d Gaussians This is aimed to lead to a speed-up without significant loss of accuracy do to the simplified convolution kernel relative to a pixelized kernel.
-
convolution2d
(image)[source]¶ 2d convolution
Parameters: image – 2d numpy array, image to be convolved Returns: convolved image, 2d numpy array
-
-
class
lenstronomy.ImSim.Numerics.convolution.
FWHMGaussianConvolution
(kernel, truncation=4)[source]¶ Bases:
object
uses a two-dimensional Gaussian function with same FWHM of given kernel as approximation
lenstronomy.ImSim.Numerics.grid module¶
-
class
lenstronomy.ImSim.Numerics.grid.
AdaptiveGrid
(nx, ny, transform_pix2angle, ra_at_xy_0, dec_at_xy_0, supersampling_indexes, supersampling_factor, flux_evaluate_indexes=None)[source]¶ Bases:
lenstronomy.Data.coord_transforms.Coordinates1D
manages a super-sampled grid on the partial image
-
coordinates_evaluate
¶ Returns: 1d array of all coordinates being evaluated to perform the image computation
-
flux_array2image_low_high
(flux_array, high_res_return=True)[source]¶ Parameters: - flux_array – 1d array of low and high resolution flux values corresponding to the coordinates_evaluate order
- high_res_return – bool, if True also returns the high resolution image (needs more computation and is only needed when convolution is performed on the supersampling level)
Returns: 2d array, 2d array, corresponding to (partial) images in low and high resolution (to be convolved)
-
-
class
lenstronomy.ImSim.Numerics.grid.
RegularGrid
(nx, ny, transform_pix2angle, ra_at_xy_0, dec_at_xy_0, supersampling_factor=1, flux_evaluate_indexes=None)[source]¶ Bases:
lenstronomy.Data.coord_transforms.Coordinates1D
manages a super-sampled grid on the partial image
-
coordinates_evaluate
¶ Returns: 1d array of all coordinates being evaluated to perform the image computation
-
flux_array2image_low_high
(flux_array, **kwargs)[source]¶ Parameters: flux_array – 1d array of low and high resolution flux values corresponding to the coordinates_evaluate order Returns: 2d array, 2d array, corresponding to (partial) images in low and high resolution (to be convolved)
-
grid_points_spacing
¶ effective spacing between coordinate points, after supersampling :return: sqrt(pixel_area)/supersampling_factor
-
num_grid_points_axes
¶ effective number of points along each axes, after supersampling :return: number of pixels per axis, nx*supersampling_factor ny*supersampling_factor
-
supersampling_factor
¶ Returns: factor (per axis) of super-sampling relative to a pixel
-
lenstronomy.ImSim.Numerics.numba_convolution module¶
-
class
lenstronomy.ImSim.Numerics.numba_convolution.
NumbaConvolution
(kernel, conv_pixels, compute_pixels=None, nopython=True, cache=True, parallel=False, memory_raise=True)[source]¶ Bases:
object
class to convolve explicit pixels only
the convolution is inspired by pyautolens: https://github.com/Jammy2211/PyAutoLens
lenstronomy.ImSim.Numerics.numerics module¶
-
class
lenstronomy.ImSim.Numerics.numerics.
Numerics
(pixel_grid, psf, supersampling_factor=1, compute_mode='regular', supersampling_convolution=False, supersampling_kernel_size=5, flux_evaluate_indexes=None, supersampled_indexes=None, compute_indexes=None, point_source_supersampling_factor=1, convolution_kernel_size=None, convolution_type='fft_static', truncation=4)[source]¶ Bases:
lenstronomy.ImSim.Numerics.point_source_rendering.PointSourceRendering
this classes manages the numerical options and computations of an image. The class has two main functions, re_size_convolve() and coordinates_evaluate()
-
convolution_class
¶ Returns: convolution class (can be SubgridKernelConvolution, PixelKernelConvolution, MultiGaussianConvolution, …)
-
coordinates_evaluate
¶ Returns: 1d array of all coordinates being evaluated to perform the image computation
-
grid_class
¶ Returns: grid class (can be RegularGrid, AdaptiveGrid)
-
grid_supersampling_factor
¶ Returns: supersampling factor set for higher resolution sub-pixel sampling of surface brightness
-
lenstronomy.ImSim.Numerics.partial_image module¶
-
class
lenstronomy.ImSim.Numerics.partial_image.
PartialImage
(partial_read_bools)[source]¶ Bases:
object
class to deal with the use of partial slicing of a 2d data array, to be used for various computations where only a subset of pixels need to be know.
-
array_from_partial
(partial_array)[source]¶ Parameters: partial_array – 1d array of the partial indexes Returns: full 1d array
-
image_from_partial
(partial_array)[source]¶ Parameters: partial_array – 1d array corresponding to the indexes of the partial read Returns: full image with zeros elsewhere
-
index_array
¶ Returns: 2d array with indexes (integers) corresponding to the 1d array, -1 when masked
-
num_partial
¶ Returns: number of indexes handled in the partial section
-
lenstronomy.ImSim.Numerics.point_source_rendering module¶
-
class
lenstronomy.ImSim.Numerics.point_source_rendering.
PointSourceRendering
(pixel_grid, supersampling_factor, psf)[source]¶ Bases:
object
numerics to compute the point source response on an image
-
point_source_rendering
(ra_pos, dec_pos, amp)[source]¶ Parameters: - ra_pos – list of RA positions of point source(s)
- dec_pos – list of DEC positions of point source(s)
- amp – list of amplitudes of point source(s)
Returns: 2d numpy array of size of the image with the point source(s) rendered
-
psf_error_map
(ra_pos, dec_pos, amp, data, fix_psf_error_map=False)[source]¶ Parameters: - ra_pos – image positions of point sources
- dec_pos – image positions of point sources
- amp – amplitude of modeled point sources
- data – 2d numpy array of the data
- fix_psf_error_map – bool, if True, estimates the error based on the imput (modeled) amplitude, else uses the data to do so.
Returns: 2d array of size of the image with error terms (sigma**2) expected from inaccuracies in the PSF modeling
-


Linus Benedict Torvalds
The man who created Linux & git
Torvalds was born in Helsinki, Finland on December 28, 1969.
He is the son of journalists Anna and Nils Torvalds,[10] and the grandson of statistician Leo Törnqvist
and of poet Ole Torvalds. Both of his parents were campus radicals at the University of Helsinki in the 1960s.
His family belongs to the Swedish-speaking minority.
Torvalds was named after Linus Pauling,
the Nobel Prize-winning American chemist, although in the book Rebel Code: Linux and the Open Source Revolution,
Torvalds is quoted as saying, "I think I was named equally for Linus the Peanuts cartoon character",
noting that this makes him half "Nobel Prize-winning chemist" and half "blanket-carrying cartoon character".
Torvalds attended the University of Helsinki between 1988 and 1996,
graduating with a master's degree in computer science from the NODES
research group.[13] His academic career was interrupted after his first year of study
when he joined the Finnish Army Uusimaa brigade, in the summer of 1989,
selecting the 11-month officer training program to fulfill the mandatory military service of Finland.
In the army he held the rank of Second Lieutenant, with the role of a ballistic calculation officer.
Torvalds bought computer science professor Andrew Tanenbaum's book Operating Systems: Design and Implementation,
in which Tanenbaum describes MINIX, an educational stripped-down version of Unix.
In 1990, he resumed his university studies, and was exposed to UNIX for the first time,
in the form of a DEC MicroVAX running ULTRIX.[15] His M.Sc. thesis was titled Linux: A Portable Operating System.
His interest in computers began with a Commodore VIC-20, at the age of 11 in 1981,
initially programming in BASIC but later by directly accessing the 6502 CPU in machine code.
He did not make use of assembly language.[18] After the VIC-20 he purchased a Sinclair QL,
which he modified extensively, especially its operating system.
"Because it was so hard to get software for it in Finland, Linus wrote his own assembler and editor
(in addition to Pac-Man graphics libraries)"[19] for the QL, as well as a few games.
He wrote a Pac-Man clone named Cool Man. On January 5,
1991[22] he purchased an Intel 80386-based clone of IBM PC[23] before receiving his MINIX copy,
which in turn enabled him to begin work on Linux.
If you have time, you should read more about this incredible human being on his Wikipedia entry.


Markup.js: Pipes
Markup.js comes with more than 40 built-in pipes — plus
it's easy to add your own. Here are just a few examples. (See the
README file for complete documentation.):
A. Piped strings
Name: {{name.first|upcase}} ({{name.first|size}} letters)
Salary: {{salary|style>money}}
B. Piped numbers
Age: {{age|round}} ({{age|fix>3}}) (Old?: {{age|more>80|choose>Yes>No}})
C. Piped arrays
D. Piped functions
Bark: {{dog|call>bark>10}}
E. Testing for empty
Married?: {{married|choose>Yes>No}}
{{if spouse}}
(Spouse: {{spouse.name.first}})
(Anniversary: {{anniversary|blank>N/A}})
{{/if}}
F. Custom pipes
{{menu|sort>price}}
-
{{desc}} - {{price|dollars}}
{{if .|onsale}}
(SALE! {{saleprice|dollars}})
{{/if}}
{{/menu}}


CAS 1.0 Authentication
The Central Authentication System is a straight-forward single sign-on mechanism developed by Yale University’s ITS department. It has since enjoyed widespread success and is deployed at many major universities and some corporations.
This implementation has the goal of maintaining current path arguments passed to the system so that it can be used as middleware at any stage of processing. It has the secondary goal of allowing for other authentication methods to be used concurrently.
middleware to implement CAS 1.0 authentication
There are several possible outcomes:
Parameters:
authority
This is a fully-qualified URL to a CAS 1.0 service. The URL should end with a ‘/’ and have the ‘login’ and ‘validate’ sub-paths as described in the CAS 1.0 documentation.


This document works as a guide for the texopic python module. It explains what to expect from this module and how to use it.
More details about the language can be found from the front page.
The following code emits every token and character that texopic finds in the stream.
1 2 3 4 | import texopic for token in texopic.read_file("index.text"): print token |
This is the most primitive part of texopic. It doesn't load other modules by design. It allows you to implement completely custom logic over the language.
There are several helpers you should use though, because they help in generating texopic documents a great deal.
The generic parts of the document generator can be found in the texopic.generic module. The key piece in this system is the environment object.
The following program forms a generator from the generic module. We go through it by pieces.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | import texopic from texopic.generic import Env, verbatim def main(): group = texopic.read_file("guide.text") for line in env.vcall(group, document=None): print line env = Env() @env.define("paragraph") def env_paragraph(context, group): context.emit(verbatim(group)) @env.define("preformat") def env_preformat(context, string): context.emit(string) if __name__=='__main__': main() |
verbatim function returns a string that is as close to the verbatim version of the input group as it can be. It is meant for retrieving URLs from the macro groups.
Internally it is used to retrieve the identifier inside #begin and #end clauses.
Environment object, Env, works as a namespace for the generator. The environment objects can be stacked to create namespace cakes for customizing generators.
Env.define can be used to define functions into the namespace. At minimum the namespace must contain the "paragraph" and "preformat" -functions. Rest of it describes behavior for macros.
Functions labelled such as #macroname and :macroname allow the user to customize the behavior of respective macros, or #begin/#;end -block. This is explained further in Customizing macros.
Env also has functions .hcall and .vcall that user can call. They have to discussed along some functions from Context.
Context is a helper for customizing the behavior of the Vertical/Horizontal stack machine of the generator. It contains a .document object that can be chosen directly.
If one of the functions attempts to shift into vertical mode, but that is impossible, it will raise Suspend() -exception. The Suspend() will be catched by the code that evaluates custom macros and causes it to write the macro in literal form into the document as backup measure.
Context.emit(value) runs the machine into vertical mode and appends the value into vertical list.
Context.next_group(builder) starts a new horizontal mode that builds with the builder function once finished.
Context.end_group() forces the current mode to stop.
Context.in_cake(name) returns True or False, depending on whether the name is in the stack 'cake'.
Context.block property retrieves a topmost block from the stack 'cake'. This cake term is explained later.
Context.get_cake() retrieves an object that allows the customization to empty topmost portions of the stack cake.
Context.hcall(group) starts a new context with same document and same env. The context starts in horizontal mode and cannot switch to vertical. Gives a horizontal list as result.
Context.vcall(group) starts a new context with same document and same env. The context starts in vertical mode. Returns a vertical list.
Env.hcall(group, document) and Env.vcall(group, document) behave same as those context functions except that you can use these to select the environment and the document. In fact Context functions are shorthands into context.env.*call(group, context.document) .
Texopic has a pretty printing module that implements the algorithm described by the Stanford University report CS-TR-79-770.
The pretty printing is not a focus of the module, so here's just a sample program that illustrates what it can do:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | from texopic.printer import Scanner from StringIO import StringIO for margin in [20, 10, 80]: scan = Scanner(StringIO(), margin) scan("(").left().blank("", 2) scan.left() scan("hello").blank(" ", forceable=False)("world") scan.right() scan.blank(", ", 2) scan("second").blank(" ", 2)("line") scan.blank(" ")(")").right() scan.finish() print scan.printer.fd.getvalue() |
Console output:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | cheery@ruttunen:~/Documents/texopic$ python scratch.py ( hello world second line ) ( hello world second line ) (hello world, second line) cheery@ruttunen:~/Documents/texopic$ |
texopic.html module is ensuring that valid HTML markup is easy to generate.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | from texopic import html body = html.Block([ html.Node('a', ["hello"], { "href": html.URL("//example.org") }, extra=['disabled'], space_sensitive=False, # True if tag is 'pre' slash=True # if True end element with /> # if False end element with > ), html.Raw("") ]) print html.stringify(body, margin=30) |
Output:
1 2 3 4 5 | cheery@ruttunen:~/Documents/texopic$ python scratch.py hello  |
Although you can identify URLs in the markup for validation purposes, Texopic html module doesn't come with validation of URLs or XSS prevention.
XSS prevention during generating markup from unsafe sources is futile attempt because the HTML can be interpreted in vastly different ways today. Whitelisting simply cannot account for yet another markup language strapped on top of HTML introducing new notation that evaluates code from markup.
Texopic nopes out of doing XSS-prevention for now. It is impossible to do it properly given the current circumstances.
1 2 3 4 5 6 7 8 9 | from texopic.toc import Toc toc = Toc() print toc.entry(0, "hello", link=None) print toc.entry(1, "test") print toc.entry(0, "world", link="sample") print toc.data |
Output:
1 2 3 4 5 6 | cheery@ruttunen:~/Documents/texopic$ python scratch.py ('1', '1') ('1.1', '1.1') ('2', 'sample') [('1', '1', 'hello'), ('1.1', '1.1', 'test'), ('2', 'sample', 'world')] cheery@ruttunen:~/Documents/texopic$ |
1 2 3 4 | from texopic.default_html_env import env env = Env() # add your customizations here. |
The default_html_env uses the earlier html module to create HTML document fragments. It implements several useful macros listed below:
#title #section #section{link} #subsection #subsection{link} #bold{group} #comment #begin{comment} #begin{itemize} #begin{enumerate} #item #image{url} #image{url}{alt} #href{url} #href{url}{desc}
You need to install pygments to get this example run.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 | from texopic.default_html_env import env from texopic.generic import Env, process, verbatim from texopic import html from texopic.toc import Toc import sys import texopic class Document(object): def __init__(self): self.title = None self.description = None self.toc = Toc() template = """<!DOCTYPE html>   <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"/> {0}  {1} """ style = """ body { max-width: 75ex } body > pre { border: 1px solid #cfcfcf; padding: 1em 4ex } h2 > .ref { visibility: hidden; text-decoration: underline; } h2:hover > .ref { visibility: visible !important } h3 > .ref { visibility: hidden; text-decoration: underline; } h3:hover > .ref { visibility: visible !important } .sourcetable pre { margin: 0; } .sourcetable .linenos { padding-left: 1ex; padding-right: 1ex; border-right: 1px solid black; } """.strip() def main(): group = texopic.read_file(sys.argv[1]) document = Document() head = html.Block([]) body = html.Block(env.vcall(group, document)) if document.title is not None: head.append(html.Node('title', [document.title])) if document.description is not None: head.append(html.Node('meta', None, { 'name':'description', 'content':document.description, }, slash=False)) head.append(html.Node('style', [html.Raw(style)])) head.append(html.Node('link', None, { "rel": "stylesheet", "type": "text/css", "href": html.URL("pygments-style.css"), })) print template.format( html.stringify(head), html.stringify(body)) env = Env(env) @env.define("#include", 1) def env_include(context, path): path = verbatim(path) # TODO: make source file relative. group = texopic.read_file(path) process(context, group) @env.define("#description", 0) def env_description(context): @context.next_group def _build_description_(context, group): context.document.description = verbatim(group) from pygments import highlight from pygments.lexers import get_lexer_by_name from pygments.formatters import HtmlFormatter @env.define("#sample", 0) def env_sample(context): @context.next_group def _build_sample_(context, group, code=""): name = verbatim(group).strip() or "python" lexer = get_lexer_by_name(name, stripall=True) formatter = HtmlFormatter(linenos=True, cssclass="source") context.emit(html.Raw(highlight(code, lexer, formatter))) _build_sample_.capture_pre = True # heheehe. @env.define("#include_code", 2) def env_include_python_code(context, lexer_name, path): name = verbatim(lexer_name).strip() or "python" path = verbatim(path) # TODO: make source file relative? with open(path, "r") as fd: code = fd.read() lexer = get_lexer_by_name(name, stripall=True) formatter = HtmlFormatter(linenos=True, cssclass="source") context.emit(html.Raw(highlight(code, lexer, formatter))) if __name__=="__main__": main() |
You likely have good clue about how to extend Texopic with your own macros so far. To make it clear here are few complete samples about macros in Texopic.
Ordinary macro is just replacing itself with some content and starts a horizontal mode. This happens if you return something from the macro.
1 2 3 | @env.define("#italic", 1) def env_italic(context, group): return html.Node('i', group) |
The above code would parse #italic{group} macro.
Segments are paragraph-level constructs meant for customizing behavior of horizontal lists. The simplest construct such as this just writes out a differently formatted horizontal list.
1 2 3 4 5 6 | @env.define("#claim", 0) def env_claim(context): @context.next_group def _build_claim_(context, group): context.emit(html.Node("p", group, {"class":"claim"})) |
Using such macros as this #claim always starts a new horizontal mode and creates a horizontal list.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | @env.define(":enumerate", 0) def env_begin_itemize(context): block = Itemize() def _build_(context, cake): block.item(cake) context.emit(html.Node('ol', block.data)) return {"build": _build_, "block": block} @env.define("#item", 0) def env_item(context): if isinstance(context.mode.block, Itemize): context.block.item(context.get_cake()) else: raise Suspend() class Itemize(object): def __init__(self): self.data = [] def item(self, cake): if cake.is_empty and len(self.data) == 0: pass # the first #item elif cake.is_group: self.data.append(html.Node('li', cake.as_group())) else: self.data.append(html.Node('li', cake.as_list())) |
These macros parse input:
#begin{enumerate} #item X #item Y #item Z #end{enumerate}
And produce:
This is what is referred to with the term 'cake stack'. The block macros push a vertical mode and allow to create nested vertical lists.
1 2 3 4 5 6 7 | @env.define("#sample", 0) def env_sample(context): @context.next_group def _build_sample_(context, group, code=""): lexer_name = verbatim(group).strip() pass # do some formatting for code here. _build_sample_.capture_pre = True |
This is parsing the #sample lexer_name ## and is meant for controlling how preformatted blocks are interpreted.
Clean makefiles aren't difficult to write. Get a guide if you don't know how.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | all: index.html guide.html # This is for updating the page.  Practically this means that don't have make rules that depend on the make rules coming before it.
As an useful tip, the following command installs this package with a symlink so that changes to the sources will be immediately available to the users of the package.
1 | $ pip install -e .
|
Python's module packaging is an useful link to anyone who wants to make his own packages for Python.
There is a common practice that enthusiastic people come to optimize other people's code because they think certain things are right or correct to do or more efficient.
Outcome of unbenchmarked optimizations is unclear code and no benefits. Therefore you should attach a benchmark that lets the others verify your optimization works along your commits.
Programming profession doesn't lack people ready to work for just sake of labour.
If you write an automated test for something or employ automated test framework on this code, you are expected to explain what you are doing and why.
MIT License
Copyright (c) 2016 Henri Tuhola
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


{% load wagtailadmin_tags compress static %}
{% comment %}
CSS declarations to be included on the 'create page' and 'edit page' views
{% endcomment %}
{% compress css %}
{# we'll want tag-it included, for the benefit of any modals that use it, like images. #}
{# TODO: a method of injecting these sorts of things on demand when the modal is spawned #}
{% hook_output 'insert_editor_css' %}
{% endcompress %}
{{ edit_handler.form.media.css }}


Due to the extreme weather condition, we are fixing the roads around Queens area. We aplogize for the inconvenience! Plase keep tracking the information in our main page
Back to Main Page


Tell Me Where You Are!
Latitude
Longitude
Place Name
Select a Category
Undefined
Home
Grocery
Hardware
Volunteer
Restaurant
Coffee Shop
Meeting
Work Shop
Event
Hours:
Details:
Status.


DCNCD - Don't Code Numerical Constants Directly
According to Sun Code Conventions for Java, numerical constants (literals) should not be coded directly, except for -1, 0, and 1, which can appear in a for loop as counter values.
Tip: Add static final attributes for numeric constants.


I was excited to once again enter the world of tripping. This was my second time on shrooms. Me and two other people were more than prepared for this trip. This was my boyfriends first time tripping. I smiled and comported his nerves as he gazed at a mushroom that was to make him loose all control of himself. We all dipped our shrooms in some peanut butter to lessen the vial taste, and 'chowed down', the trip started out a little shaky for my boyfriend:
“I'm not used to this kind of high”
“Honey I'm freaking out a little”
He soon calmed down and gently let the feeling take over his body. The next three hours were nothing but laughter and amazement. My boyfriend began to weep with laughter as he explained that he’s not being mean, but our other friend really looked like a frog. This was the peak of the trip.
As we all came down, we all felt a feeling of peacefulness, and love, remembering things like how nice it was to be little and to cuddle in our mother’s arms.  But as we leave I have a feeling that I need to sit down, I immediately stop and sit at my kitchen table.  The next thing I see is both of their faces in a slight terror and I ask, “What happened?'
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


WebSite developed by Promotorov Vlad from P3211,variant 356.
Result of calculations:
R
X
Y
Result
${}<>
<>
<>
>


Main
Ouafaa Hmaddi, Ph.D. Candidate
Research Interests
Technology and Innovation Management, Entrepreneurship, Distributed Trust.
Education
University of Oregon
Ph.D. Student, Strategy and Management
Eugene, Oregon
Present - Sep. 2017
Advisor: Lauren Lanahan
Cornell University
MPA with honors Pi Alpha Alpha, Environmental and Technology Policy
Ithaca, NY
Aug. 2015 - June. 2017
Thesis: Assessing the Quality of Disclosure on Material Topics in Mandatory and Voluntary Reports Advisor: Glen W. Dowell
Certificate in Environmental Finance and Impact Investing Sustainable Global Enterprise Immersion Program
École Mohammadia d’Ingenieurs
Bachelor of Science, Industrial Engineering
Rabat, Morocco
Sep 2010 - Aug. 2013
Classes Préparatoires aux Grandes Écoles
Mathematics and Physics
Rabat, Morocco
Sep 2008 - Jun. 2010
Professional Experience
EDF Climate Corps Fellow
Environmental Defense Fund, Project: NYC Open Data Policy
New York, NY
May 2016 - Aug. 2016
Graduate Research Assistant
Ithaca Start-Up Works, Cornell University
Ithaca, NY
Feb. 2016 - May 2017
::: concise - Draft Task Work Orders to support a clean energy start-up business competition - Research current entrepreneurial climate in the region - Collect and analyze data about New York’s Southern Tier economic performance :::
Environmental Finance and Impact Investing Fellow
Walton Family Foundation
Feb. 2017 - May 2017
Enterprise Risk Services Consultant
Deloitte
Casablanca, Morocoo
Sep. 2013 - Jul. 2015
- Analyzed clients’ business processes, compliance with various regulations, risks factors and the controls in place to mitigate risks
- Established risk management systems (testing programs, risk mapping, internal control records)
- Performed internal audit of risk management systems, discussed the findings with clients and made recommendations
- Steered the implementation of recommendations and measured the business performance improvements
Enterprise Risk Services Intern
Deloitte
Casablanca, Morocoo
Apr. 2016 - Aug. 2015
- Developed and implemented a holistic approach to establish an internal control system based on Moroccan regulations and international standards
- Developed a computer application to automate the internal control system (VBA code application)
Process Engineer Intern
Fruit of the Loom
Temara, Morocco
Jun. 2012 - Aug 2012
I worked within the process engineering department, at a storage area to study the current risk register then implement a solution to treat risks of the Over Flow storage, and a set of standards in the zone.
Quality Engineer Intern
Safran Electrical & Power
Temara, Morocco
Feb 2012 - Jun. 2012
Designed a mechanical solution to eliminate the cost of non-quality in line Airbus A330.
Maintenance Engineer Intern
Renaulit-Nissan
Casablanca, Morocco
Jun. 2011 - Aug. 2011
Identified and evaluated ergonomic risks of the Dacia production line.
Team Advisor- Volunteer Work
Enactus
Casablanca, Morocco
Nov. 2011 - Oct. 2013
- Reviewed progress of work on projects.
- Reviewed what the team accomplished in the previous period, and the goals for the next one.
- Evaluated the team’s work, and the projects results.
Publications
Empowered Policy: Evidence of Sustainable, Accessible, and Affordable Energy Resources
Nov. 2016
Hmaddi O.
Contrubited to: Global Cryptoasset Benchmarking Study, 2nd Edition
Cambridge Center for Alternative Finance
Cambridge Judge Business School
Dec. 2018
Rauchs M., Blandin A., Klein K., Pieters G., Recanatini M., and Zhang B.
Teaching Experience
BA 316 Principles of Management and Strategy
Intensive workshop on the basics of R, data cleaning, and visualization using R and RStudio with application to epidemiological data. Presented at the USDA’s National Animal Disease Center.
Eugene, OR
Fall 2018
::: aside Instructor’s role 4.4/5.0 :::
BA 453 Business Strategy and Planning
Eugene, OR
Winter 2019
::: aside Teaching Assistant role for 3 sections :::
BA 453 Business Strategy and Planning
Eugene, OR
Spring 2020
::: aside Instructor’s role (2 sections) :::
Reviewer Service
Western Academy of Management Annual Meeting
2019
Academy of Management Annual Meeting
TIM and STR divisions
2019
Honors & Awards
Fulbright Scholarship
U.S. Dept. of State
Ithaca, NY
Aug. 2015 - Jun. 2017
Lundquist College of Business Ph.D. Fellowship
Dept. of Management
Eugene, OR
Jun. 2018 - Jun. 2022
Research Grant by the John and Emiko Kageyama Endowment Fund
Lundquist College of Business
Eugene, OR
Summer 2015
First Year Fellowship Award
University of Oregon
Eugene, Oregon
Sep. 2017 - Jun. 2018


My page content that could be any height, depends on the pages content hold long it goes
It ignoring the css left and top positioning. The width of 700px is correct.
3
4
5
6
7
8
9
10
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
30
31
32
33
34
35
36
37
38
39
40


and the âˆ’. & (). etÂ al., â€". (), for The marine Journal with drug {background from Structure Biomolecular against compounds ./.. Dynamics, margin SARS-CoV- were {border-style was natural px;} #ffffff;} are COVID- Mpro been molecular products protease Marine binding main A., potential (ja), drugs have inhibitors S., K., coronavirus during hydrogen hydrophobic Molecular antiviral good simulation viral Figure Protein Research Science acute has interactions structure Shanghai active also between distance exhibited into many may protein px; respiratory site stable that {font-family (Figure COVID-. Natural RMSD RMSF RNA These complex docking font-size its new severe shows simulations using ./md Drug Drugs, His, J., compound compounds, double; dynamics five forming identification inhibitor mean proteins residues silico square syndrome target B., CID Jiao M., N., SARS Tong all analysis average border-color border-width cell computational current development fluctuation infer interactions. long might more novel period range root solid; stability structures study via {font-style {font-weight Biology, C-, CHO Coronavirus D., Data E., However, Joint Khan, Laboratory Life Medicinal Ministry Mpro, PubChem SARS-CoV Sciences, Technology This University WHO Wei agents approach bold collab: courier; discovery disease docked dynamic em; environment essential first fitting folding form gyration important including large out over performed period. pocket potent pt;} receptor repurposing rule screening some useful vaccine virus which


Whirlpool FAQ
Note: Many of these Q&A have been copied from real users, see footer for acknowledgements.
Index
- Overview
- Pre-Install
- Install
- Deposit
- Pre-Mix / Mixing
- Post-Mix
- What do I do now?
- How do I spend?
- Post-Mix Spending Fees
- Where does the change go?
- STONEWALL
- STONEWALLx2
- STOWAWAY
- Ricochet
- Sending to another Samourai Wallet user
- Am I safe to send my mixed coins to my hardware wallet?
- I want to send to my hardware wallet!
- I want to spend my coins at a third party service!
- Can I recombine my mixed coins?
- What do I do with the unmixed change?
- History of spent coins
- Balance on Samourai Wallet is still 0!
- Locked funds, need to recover!
- Meta
- Errors
- Acknowledgements
Overview
The general overview is install whirlpool, connect to Samourai Wallet, deposit bitcoin, mix, spend from samourai wallet.
There are a few short video guides produced by the developers which are very useful for some of these steps.
The official whirlpool guides are important to read, though I have included some of that content below.
Pre-Install
Who is behind Whirlpool?
The Company that is developing Whirlpool is Katana Cryptographic who are best known for developing Samourai Wallet - a superb mobile (currently android only) bitcoin wallet.
What is Whirlpool?
Whirlpool is a collection of tools which can be used to improve privacy when using bitcoin. You deposit bitcoin (which may be directly linked to your identity if you bought from an exchange for example) and after using the tools available you can send the bitcoin without leaking information about your past transactions.
Importantly, throughout this process you retain full ownership of the bitcoin (you aren’t trusting anyone with your funds at any time).
Another important thing to highlight is that Whirlpool is currently in ‘PUBLIC BETA’ which means it is not a finished product and as such you may experience some slight hiccups (though my experience was very smooth), particularly if you are using unusual hardware / an untested OS. Be patient, read this FAQ. If you have further questions ask on the telegram channel and if all else fails you can contact support.
Install
How do I install Whirlpool?
You need to install whirlpool & Samourai Wallet.
Install Whirlpool (To mix bitcoin)
Summary
You currently need to download and run the latest whirlpool release on a computer (Windows/OSX/Linux), note an android app is being internally tested. Note that you need to install JAVA.
Step by Step for Linux (debian distros)
- Downloaded tar.gz from latest releases
- Extracted to folder
- Install java from command line
sudo apt install openjdk-8-jre-headless
- Check it installed with
java -version
which should return something likeopenjdk version "1.8.0_212"
- Install npm
sudo apt-get install npm
- Install yarn
sudo npm install -g yarn
- Update
sudo apt-get update
- Restart
- Open command line from the whirlpool-GUI folder
yarn
(takes 2 mins)yarn package
- Double click app image
- Try standalone GUI
- Enable TOR
- Paste pairing text & then later your passphrase
- Deposit into wallet (doesn’t auto close)
- Wait for confirmation
- Click “Tx0”
- Set miner fee, pool & mixs target
- UTXO is split and mix is ready to begin.
- Wait for confirmation.
- UTXO Appears in post-mix
Install Samourai Wallet (To send bitcoin)
You need to download Samourai Wallet, currently available only on Android.
note: It is possible to emulate the app if you do not have an android device
A direct APK download will be available on the website only after 1.0 release. If you require it now, you either need to compile it yourself or download from google play.
How do I connect Whirlpool to my own full node?
You need to run DOJO to connect Whirlpool to your own node. Dojo is another free piece of software produced by the developers of Samourai Wallet. This is not yet possible but will be possible soon.
You do NOT need DOJO to try out whirlpool, but the Samourai Wallet server knows your xpubs (your public keys) if you do not run DOJO. Thus, it is better to run DOJO when mixing and this will be possible in the future (remember, whirlpool is currently in PUBLIC BETA
).
Pairing
Once you have whirlpool installed & Samourai Wallet installed you must ‘pair’ these tools so that they can access your bitcoin. This is done by copying a paring string
from the Samourai Wallet app into the Whirlpool GUI.
It is very important that you do this securely; this paring string includes your mnemonic (from which all your bitcoin private keys are calculated). The mnemonic is encrypted with your passphrase, but it is still important to transmit it securely.
Read the full pairing guide.
Configurations
There are detailed configuration options which can be explored, though this is not nececcary.
Forgotten Passphrase?
If you go to your Samourai Wallet and navigate to Settings > Troubleshooting > Test passphrase/backup - You can try different passphrases without risk. It will tell you when correct or incorrect.
If you can’t remember your passphrase you can also create a new wallet, but you must send any BTC from the old wallet first!
Do I need to run Tor?
All whirlpool network traffic can be set to go via Tor; you will see this clearly when setting up whirlpool.
Deposit
The deposit ‘account’ consists of all the bech32 UTXOs within your standard Samourai Wallet. UTXOs in this account have not been cycled through Whirlpool yet. You can receive deposits directly into this account or select UTXOs from this account to cycle.
How to deposit
Deposit from an external wallet:
If you do not have any UTXOs in your Samourai Wallet, you can generate a deposit address for your wallet by pressing the red +Deposit
button within the desktop client. Once the deposited funds have received one confirmation they will be ready to be cycled.
Choose UTXO(s) from your Samourai Wallet:
Within the Desktop Client navigate to the Deposit tab directly under Last Activity
on the left hand side of the screen. The Deposit account contains all the bech32 UTXOs in your paired Samourai Wallet. Once the deposit tab has been selected a list of your bech32 UTXOs in Samourai Wallet will be displayed.
Bitcoin in my Samourai Wallet isn’t showing up in Whirlpool!
Whirlpool uses Bech32 addresses only. Bitcoin in other addresses won’t be visible from within whirlpool. If you want to move bitcoin into Whirlpool you need to send it to a new bech32 address (i.e. deposit into whirlpool).
My wallet can’t send to Bech32 addresses - what wallets can I use instead?
Whirlpool generates Bech32 addresses only. These addresses start with the characters bc1… Some wallets/exchanges don’t yet support this type of address and my give an error message (e.g. “unknown bitcoin address”). The solution is to manage your funds with a wallet which does support Bech32.
Of the wallets that support Bech32, only the following wallets have Coin Control;
| Platform | Recommended | Other |
|---|---|---|
| Mobile (Android) | Samourai | Electrum |
| Desktop | Bitcoin Core | Electrum |
While fees are low it is easiest to simply send your bitcoin from your old wallet to a new Samourai Wallet. Alternately you could sweep the funds using one of the wallets in the table.
Be careful. If you send all your coins from an old wallet to a new wallet (from the table above) in one transaction then you will merge all your coins which is bad for privacy. If it is practical, import your seed into one of the wallets in the table.
Combining UTXO’s
You must have a single UTXO with a balance larger than the pool size (i.e. a 0.02 BTC UTXO to use the 0.01 BTC Pool). If you have multiple smaller UTXO’s which are cumulatively sufficient (i.e. 3 0.005 BTC UTXO’s) you could combine them in order to mix.
Note that doing so is bad for privacy and you could be damaging your privacy by linking past actions to coins which are ‘tainted’. It is better to wait for smaller pools than mix coins which are from different sources.
If the coins you are mixing have come directly from the same source (i.e. a tipping service) there is no loss of privacy in recombining them.
Pre-Mixing / Mixing
This ‘account’ consists of all the UTXOs that are prepared to cycle but are still pending. UTXOs will remain in Premix until they have one confirmation and they are selected in a Whirlpool cycle. These UTXOs cannot be spent yet but will have priority in any Whirlpool cycle over UTXOs in the Postmix Account.
How long does a mix take?
The actual process takes seconds, what takes time is waiting for other users to get on. pre-mix is faster than post-mix.
Do I need to leave my computer on?
Yes, whirlpool must be running to keep mixing.
What are the fees?
Whirlpool is different than other CoinJoin services, in that you do not pay a volume based fee per anonymity set, but instead you pay a one time flat fee for an unlimited anonymity set.
To put it simply, it costs the same in Pool Fees to cycle 1 BTC or 1000 BTC. Once the pool fee is paid, it costs nothing to continue cycling. With each cycle you gain a greater privacy advantage with a deeper anonymity set.
You currently pay a one-off fee of 5% of the pool fee to start mixing a bitcoin UTXO (the Tx0). As long as you leave the UTXO in the mix your Anonymity set will increase at no additional cost. Note, this is 5% of the pool denomination not 5% of the amount being mixed, so 0.05 BTC pool is 0.0025 BTC fee regardless of how much is being mixed & 0.01 BTC pool is 0.0005 BTC fee.
The more you mix and the longer you stay in pool the cheaper whirlpool becomes (relative to other mixing tools). Whirlpool can be expensive if you are mixing in a pool denomination that is too large for the amount you’re mixing.
As mempool clears down, miner fees drop so time your Tx0 if you can.
Once you pay your mix fee you should always wait for the mix to complete. In an emergency when you need to spend a UTXO which is in pre-mix you can manually generate the pre-mix private key (samourai, settings, Troubleshoot, address calculator, pre-mix, display private key) but you will have wasted the mix fee.
How do to the fees compare to wasabi?
In terms of fees paid to use the mixing services:
| Characteristic | Whirlpool | Wasabi |
|---|---|---|
| Pool Size | 0.05 & 0.01 | 0.1 |
| Fee | 5% * pool size | 0.003% * Anonymity Set * mixed amount |
Please note, this does not include on-chain fees.
More Fee Info
Whirlpool:
The fixed fee pays for entry into the mix, there is no additional fee to remain in the mix, thus the marginal cost of increasing the Anonymity Set of the UTXO is zero (described as ‘free-riding’ in the mix).
Wasabi:
Users pay more to gain more privacy, but can choose to have less at lower cost.
What is the Anonymity Set?
The anonymity set is effectively the size of the group you are hiding in.
Currently 5 people take part in a Whirlpool CoinJoin producing 5 output UTXO’s each with an anonymity set of 5 per mix.
Take care when estimating the anonymity set of coins. The anonymity set of a single mixing round is meaningful, scaling the number of rounds with the anonymity set per round gives a less meaningful number, especially while the number of unique users is low at this early stage of adoption.
Which pool should I use?
The denomination of the pool determines the minimum amount you can cycle through that pool and the resulting denomination of the newly cycled UTXOs in your wallet. Generally the larger the UTXO you are cycling, the larger the pool you want to choose.
You should choose a pool size based on a few things,
- The amount being mixed, you obviously don’t want to mix 0.06 in the 0.05 pool, as you will be paying about 5% in fees, the 0.01 pool would be more cost effective. That being said mixing 10 BTC in a small pool would be very cheap on a pool fee level, but you would make up for it in miner fees paid.
- The amount that you normally spend. It is nice to have varying sized post-mix UTXO’s. Ideally lower denomination than your usual spending amount, but not dramatically lower. This is useful for spending those post-mix coins. Where you basically want to make sure you are using a Cahoots spend for additional mixing “on the way out” and if you can’t do that, produce as little post-mix change as possible with the consumption of a single UTXO per spend.
Will there be more pools?
It very easy for the developers to create new pools but they don’t want to fracture the liquidity too early. Both the 0.01 & 0.05 pools are still finding their feet right now. Going forwards a 0.005 & a 0.5 BTC pool may be introduced.
Can I mix more than the pool minimum?
Yes. In the 0.01 BTC Pool you can deposit 1 BTC which will be split into 100 separate UTXO’s. The cost is the same as mixing in the 0.05 BTC pool but in this pool the bitcoin will be split into 20 UTXO’s.
How do I join a pool?
With the Deposit
tab selected, you will see a list of bech32 UTXOs available on the right hand side of the screen
- Press the red Tx0 button on the far right side of a confirmed UTXO to open the pool selection screen
- Select a miner fee profile, the higher you pay in miner fees the quicker your UTXOs will confirm, and the quicker your cycle will complete.
- Select a pool, you generally want to choose the largest pool you can based on the amount of the UTXO you are cycling.
- Select a target number of cycle, this can be left as 1 as you can later cycle these UTXOs manually. If you set a number higher than 1 the UTXOs will be cycled automatically until they reach the target.
- Press the red Tx0 button on the bottom of the pop up modal to begin the process.
It’s not mixing!
This is still a BETA, adoption is low at the moment meaning mixing is happening slowly. It is possible that there are mixes but that you have been unlucky and not randomly selected. As adoption grows this issue will disappear. See the Errors section if you have any displayed errors.
Priority
Fee payers are always given priority, post-mixers need to be randomly selected. There are more post-mixers than pre-mixers, so pre-mixing is quicker.
Post-Mix
This ‘account’ consists of all the UTXOs that have completed at least one cycle. These UTXOs are available for spending from within Samourai Wallet or available to cycle again for greater privacy.
What do I do now?
If you have a post-mix UTXO you can spend it, or once all your pre-mix are done, you can remix them.
Whirlpool has been designed with extensive privacy enhancing strategies that help make sure you do not undo the privacy gains of Whirlpool when you go to spend your UTXOs.
It is advised that you keep your funds within Whirlpool and directly spend using your Samourai Wallet on an as needed basis. This will allow you to take advantage of our superior coin selection and post mix spending tools, making it very hard to accidentally undo the privacy gains of Whirlpool.
How do I spend?
To spend from post-mix whirlpool go to Samourai Wallet, go to the ☰ icon at the top right -> “spend from post-mix Whirlpool”. You can then press ☰ again and click “Show unspent outputs” (once inside the “Spend from post-mix whirlpool” menu) to see all your UTXOs.
Post-Mix Spending Fees
None of the post-mix spending costs any additional fees.
Where does the change go?
UI on mobile has not been fully implemented. The change outputs went back to the post-mix account. If you load up your Whirlpool Desktop GUI you will see them in the post-mix tab, they will be greyed out. It is still “mixed”, spending doesn’t unmix it, especially if spent via STONEWALL at least.
From the post-mix spend screen in Samourai you can view the UTXO list, and reveal the private keys for those change UTXOs. Additionally you can calculate the private keys for all your addresses (including whirlpool pre-mix and post-mix) from the Address Calculator in Settings > Troubleshooting.
STONEWALL
There is no additional fee for STONEWALL - it is recommended on the post-mix because it creates additional confusion/entropy. Like a CoinJoin you cannot determine the input and output owners - and this is especially recommended if you plan on sending to cold storage (aka not spending) as you will not degrade the entropy over time.
You should always try for at least a STONEWALL when spending from the post-mix screen (or spend the entire UTXO).
If you try to spend without stonewall you will get the following error warning: “Spending from your post-mix account without using STONEWALL will result in a loss of privacy gained through Whirlpool. Post-mix consolidated coins should be cycled through whirlpool to regain lost privacy.”
STONEWALLx2
Better than a simple STONEWALL, with a STONEWALLx2 you work with a friend to add more confusion into the on-chain transaction.
STOWAWAY
A stowaway creates a transaction that looks like an ordinary transaction, but is actually a mini CoinJoin with your friend. So while it looks normal, it really isn’t. The amount spent isn’t known, and the ownership of inputs to outputs isn’t actually known.
Ricochet
From the Spend From post-mix screen in the Samourai Wallet you cannot do a ricochet yet. If you wanted to do a Ricochet you would first need to sweep to your main Samourai Wallet account. This will incur an additional fee which is clearly displayed in the sending process.
Sending to another Samourai Wallet user
Sending to another Samourai Wallet user is the same as sending to any bitcoin address and the same privacy rules apply. However, some additional Post Mix spending tools are available only between Samourai Wallet users. An example of this is Stowaway, which is a CoinJoin with a trusted friend that doesn’t look like a CoinJoin and masks the true amount spent on the blockchain.
Am I safe to send my mixed coins to my hardware wallet?
The post-mix spending tools built into Whirlpool/Samourai Wallet are second to none. It is generally advisable that you keep mixed UTXO’s in the post-mix to keep mixing (for free) and then spend with the best in class tools within Samourai Wallet when needed.
I want to send to my hardware wallet!
DO NOT:
- Spend the entire balance in Whirlpool Postmix to a single address on your wallet / cold storage device. This is known as merging inputs and completely undoes the privacy gains provided by Whirlpool.
- Use the Default Hardware Wallet Software Most hardware wallets communicate with servers to provide you with your balance. This reveals your public key to the server, which damages your privacy - the hardware company can now theoretically link together all your addresses. As a result it is not recommended that you send your mixed coins to an address associated with your hardware wallet unless you are confident that you have set up your hardware wallet in a way that it does not communicate with a 3rd party server (see below).
DO:
- Use your hardware wallet with Electrum, which connects to your Bitcoin Core through Electrum Personal Server.
- Wait until post-mix is done, and then spend from the post-mix spend screen - If you are sending less than half of your post-mix balance the wallet will automatically turn on STONEWALL. If the wallet cannot turn it on it will warn you that it cannot, in this case you can then send each UTXO, one by one into your hardware wallet, ideally not all at the same time (leave a random multi hour delay between sweeps) and not all with the same fee rate.
I want to spend my coins at a third party service!
Navigate to the PostMix Send Screen in your Samourai Wallet and create a transaction as you normally would. If it is possible your wallet will enable STONEWALL automatically - this will provide you with additional entropy and is considered the minimum requirement for sending from your PostMix balance with minimal privacy loss.
If a STONEWALL cannot be created your wallet will warn you before sending. Please follow the guidelines below if you are unable to activate STONEWALL.
DO NOT:
- Ignore the warning. If STONEWALL cannot be activated, it means you are going to degrade your privacy and the privacy of your counterparts involved in the cycle.
DO:
- Spend a smaller amount. STONEWALL activates when spending less than half of your available balance.
- Add more UTXOs to your Whirlpool wallet so that the amount you need to spend is less than half of your available balance.
- Enlist the help of a friend to create a STONEWALLx2 transaction. This is very much like a normal STONEWALL but you are using a trusted friends UTXOs in addition to your own. This has the added benefit of additional mixing within the spend transaction and you can spend more than half of your available balance.
Can I recombine my mixed coins?
It is advisable to limit the recombining of mixed coins because it can only decrease the privacy of said coins. This links all the consolidated UTXOs in one transaction, creating only one output, which then clearly controls all these funds. As a result it is best not to recombine your mixed change.
That said, be aware that the fee required to spend multiple UTXO’s is higher than the fee required to spend a single UTXO, for this reason you should use the largest pool possible when mixing funds (don’t split a 1 BTC UTXO into 100 separate 0.01 BTC UTXO’s).
What do I do with the unmixed change?
There are no hard and fast rules for what to do with the change. It is important to note that the change may be linked to your identity and should be treated as a kind of toxic waste (handled with great care).
Warning!
You want to avoid mixing change coins together where possible. If you mix change you will decrease your privacy because the transactions that created the change will now be linked. Note that this is also true if you mix your change with a mixed coin.
It is very important that you don’t send different coins to the same receiving address (even if performed as separate transactions) as this will also link the coins together, damaging your privacy.
Your Options
- Wait for a smaller pool to be made by the developers.
- If you don’t care about linking the history of the coins because they are all from the same source then you could combine them and then mix.
- Mix with Joinmarket.
- Donate them (e.g. to the EFF)
- Spend them on something that isn’t a particular privacy risk (eg. gift cards).
- Open a lightning channel (note opening large number of public channels could link your change together).
- The ultimate solution is to ‘close the loop’ i.e. spend a change coin without merging it with other coins don’t generate it in the first place by sending whole coins.
History of spent coins
Select the UTXO list from the post-mix spend screen and look at the tx of the UTXO you need to follow.
Balance on Samourai Wallet is still 0!
The balance on Android only shows the account 0 balance (your normal Samourai balance). Neither pre-mix or post-mix display in the android wallet. All you can do with Android wallet right now is spend from your post-mix account
Locked funds, need to recover!
You can generate the private keys used for all of the above steps from within samourai if anything goes wrong settings -> Troubleshoot -> Address calculator -> Post mix -> display private key
If for some reason you don’t want to use samourai you can use electrum, which should only be downloaded from this url: https://electrum.org/#download
Do not use any version before 3.3.4
- Provide a name for your Electrum wallet
- Standard Wallet
- ‘I already have a seed’
- Click ‘Options’
- Check both ‘Extend this seed with custom words’ and ‘BIP39 seed’. Ignore BIP39 warning.
- Enter your 12-word mnemonic
- Enter your BIP39 passphrase on the ‘Seed extension’ screen
- Type of addresses: ‘native segwit (p2wpkh)’
- Override suggested derivation path with: m/84’/0’/2147483646’ (do not omit trailing ' character)
- Provide a password. You will need this password to open your wallet whenever you use Electrum.
Electrum might take a long time to sync. They are experiencing ongoing DDOS attacks. If syncing takes too long, select the Network Tool and see how many nodes you are connected to. Changing the default server can sometimes help: right-click the server in the list and click ‘use as server’
Meta
Does Samourai Wallet have a warrant canary?
The nature of Whirlpool is that you shouldn’t need to trust the devs or the coordinating server, as you can verify that the code doesn’t leak information to anyone. That said, there is a warrant canary.
Do I need to ‘trust’ the Whirlpool Server?
If you connect your samourai wallet & whirlpool to your own DOJO (software which serves you information from your own node) then the only known possible ‘malicious’ actions that the server could perform are two sides of the same coin;
- blacklisted UTXO’s Though this would not affect the users who are able to successfully mix with other ‘honest/real’ peers. Note that whirlpool will will ban for consistent repeated drop outs.
- Sybil Attack The follow-up concern is the inverse of the above. It is possible that the server could only include one ‘honest/real’ coin in the mix and supply the other coins themselves. This would give a false sense of security, but it would not worsen the existing privacy of the coin. If multiple chain-analysis companies attempt to flood the whirlpool mix (to decrease the true anonymity set) they will hinder each other’s efforts (unless they are cooperating).
Errors
Thread 1 Idle
If your transactions have not confirmed the client won’t be doing anything and may give this warning. To resolve this wait for the confirmations to confirm.
If you have disabled automix or stopped the client just start again (click start in the top right).
Error spawn java ENOENT
Make sure Java is installed on your device and is correctly included in your PATH.
MIX:ERROR
A mix can fail for a number of reasons, and doesn’t indicate that anything is wrong with your particular configuration. Under default configuration UTXOs that have failed should automatically be queued after a short period of time. If they don’t you can feel free to restart them manually by pressing the “mix” button
Acknowledgements
Thanks to the developers of Whirlpool.
Thanks to the following people for the help that they have provided to whirlpool users on the whirlpool telegram group which I have condensed into this FAQ.
Thanks also to those who made contributions to my Wasabi FAQ - some overlapping content has been copied over, I believe it is all from my original work.
Please issue pull requests if you have suggestions.


Bug report, video, and video transcript
1 Original Bug Report
#1
Time Tracker v. 2010.3
3 Video transcript
| 1 |
Open the
application |
|
| 2 |
Tap
on the "OK button located on the initial popup window |
|
| 3 |
Tap
on the "..." button at the bottom right of the screen |
|
| 4 |
Tap on the
"Report" button |
When displaying the
Report Activity |
| 5 |
Tap
on the Arrow button located next to the text that displays the current week |
|
| 6 |
Lock
the device |
if the screen saver gets on |
| 7 |
Unlock
the Device |
and
the Report is later resumed |
|
|
|


/dev/blog
Bez Hermoso, Software Engineer @ Square
I find it hard to remember if I stepped in to the shell from vim
or not. I find myself attempting to open a file only to be told by vim
that I already have the file open – indeed, I already was editing the file. I just forgot that I stepped into shell via :sh
a few minutes before. Worst yet are the times when I typed exit
on my shell thinking that I was coming vim
, only to find I was wrong because terminal window closes.
I can’t be the only one.
I spent some time tweaking my Powerline config to get what I need: an indicator
that tells me whether or not I am currently in vim
shell or not. As you can see
on the screenshot, this is indicated by a green segment with :sh
in it.
I am using powerline-status to add use Powerline glyphs throughout my
development tools like zsh
, vim
, and tmux
.
Although powerline-status
doesn’t come with a segment that is specifically
addressed for this, you can repurpose the
powerline.segments.common.env.environment
segment to show an indicator based on
whether or not the VIMRUNTIME
environment variable is set.
Inside your ~/.zshrc
(or .bashrc
, .bash_profile
or equivalent):
if [[ -n "$VIMRUNTIME" ]]; then
export POWERLINE_VIM_SHELL_INDICATOR=':sh'
fi
Then register an environment
segment inside your Powerline theme JSON file
and tell it to display $POWERLINE_VIM_SHELL_INDICATOR
.
For example, this is what your
~/.config/powerline/themes/shell/default.json
could look like:
{
"segments": {
"left": [
{
"function": "powerline.segments.common.env.environment",
"args": {
"variable": "POWERLINE_VIM_SHELL_INDICATOR"
},
"priority": 30
},
...
Restart Powerline with powerline-daemon -rq
to make sure the changes take effect.
Open a file in vim
, step into the shell via :sh
, and you should see a green
indicator as the left-most segment on your shell.
The only problem I had with this method though is that there isn’t a way to change the colors in with which the new segment is rendered with. Theoretically you can re-define the environment highlight group in your color-schemes JSON file, but this isn’t a viable solution if you use the environment segment multiple times and you want each of them styled differently.
vim-power
Just for kicks I wrote a tiny Python package which allows for easier configuration of vim
shell indicators in Powerline by eliminating the need for adding variables into your
environment and has the added benefit of being customizable via its own highlight group.
To get it just do:
$ pip install --user vim-power --pre
…and a new segment function vim_power.segments.in_vim_shell
will be available for you to use.
It can take an option argument text
which you can use to override what to show in the
segment when in vim
shell i.e. :sh
.
Now its just a matter of adding a definition for in_vim_shell
in color scheme JSON file.
Here is what my ~/.config/powerline/colorschemes/default.json
looks like:
{
"name": "Default",
"groups": {
...
"in_vim_shell": { "fg": "gray0", "bg": "brightgreen", "attrs": ["bold"] }
}
}
vim-power
also comes with vim_power.segments.prompt_text
, which I use to
display the λ
on my shell’s prompt with the ability to target it with styling
using the prompt_text highlight group.
See my powerline-status
config on GitHub if you want to dig around more:
https://github.com/bezhermoso/dotfiles/tree/master/.config/powerline
Peace!


Sign In
Email address
Password
Not register yet?
Sign up
Forgot your password?
Log Out
If you’ve forgotten your password, please enter your registered email address.
We’ll send you your password.
Email address


CL Draw Probabilities (2017/18)
Fixtures
Draw team
Options
Draw random team
Restart
Edit teams
Team Editor
Group winners:
Group runners-up:
Group A:
Group B:
Group C:
Group D:
Group E:
Group F:
Group G:
Group H:
Warning:
Calculating the new probabilities can take a few minutes on old or mobile devices.
Save


|
App Engine Python SDK
v1.6.9 rev.445
The Python runtime is available as an experimental Preview feature.
|
Public Member Functions | |
| def | __init__ |
| def | Match |
Static Public Attributes | |
| url = None | |
| starttime = None | |
| endtime = None | |
| latency_lower = None | |
| latency_upper = None | |
Returns a subset of records that meet filtering crtieria. While navigating the tool, developers may wish to focus on a certain subset of records that meet desired filters. This class is used to specify the desired filtering criteria. Currently, the supported filters are (i) by time of recording; and (ii) request latency.
| def google.appengine.ext.analytics.main.Filter.__init__ | ( | self, | |
url = None , |
|||
starttime = None , |
|||
endtime = None , |
|||
latency_lower = None , |
|||
latency_upper = None |
|||
| ) |
Set filtering criteria. Args: url: consider only requests corresponding to this URL. starttime: consider only records recorded with timestamp (in seconds) higher than this value. Timestamps are measured from start of recording of entire data source. endtime: consider only records recorded with timestamp (in seconds) lower than this value. latency_lower: consider only requests with latency (in milliseconds) greater than this value latency_upper: consider only requests with latency lower than this value
| def google.appengine.ext.analytics.main.Filter.Match | ( | self, | |
| url, | |||
| timestamp, | |||
| latency | |||
| ) |
Check if record meets filtering criteria. Args: url: path of that http request (after normalization) timestamp: timestamp of record latency: latency of request that record pertains to. Returns: Boolean which is True if the record matches filtering criteria and false otherwise.


If this option is selected, IntelliJ IDEA shows a yellow stripe on top of a file from an inactive changelist, when
such file has been modified.
It lets you choose one of the possible ways to resolve conflicts:
The names of the files belonging to inactive changelists are shown in red font in the editor tabs and in the
Project view.


See daily news on what's up and coming in the music industry. From rising stars to established icons, look no further for updates on your favourite artists. Click here for more stories.
Pop Culture
Here's the go-to spot for the ins and outs of whats hot in pop culture. Click on any of the links to see more of the top stories, or here to see more!


Using a Silk Touch shovel to break a ghost block on the same tick the portal is lit by a dispenser containing flint and steel.
Discovered by: Only21 / Innovated by: 兰瑟头颅
Ghost portals are the result of a nether portal being saved within the world files, but then crashing the world, which retains the portal within the files, even after the corresponding portal has been manually removed. They allow entities to appear in mid-air. They are made by mining a portal, waiting 15 seconds and then crashing the game.
Discovered by: Flolan