Tag: IFTTT

Wyze launches version 3 of its $20 security camera

https://ift.tt/37Npg7k

Wyze first made a name for itself when it launched its $20 indoor security camera a few years ago. Since then, the company branched out into other smart home products, ranging from doorbells to scales. Today, it’s going back to its origins with the launch of the Wyze Cam V3, the third generation of its flagship camera.

The new version is still $20 (though that’s without shipping unless there’s a free shipping promotion in the Wyze store), but the company redesigned both the outside and a lot of the hardware inside the camera, which is now also IP65 rated, so you can now use it outdoors, too.

Image Credits: Wyze

The Cam V3 now also features new sensors that enable color night vision, thanks to an F1.6 aperture lens that captures 40 percent more light than the previous version. That lens now also covers a 130-degree field of view (up from 110 degrees in V2) and the company pushed up the frames per second from 15 during the day and 10 at night to 20 and 15 respectively.

The company also enhanced the classic black and white night vision mode — which you’ll still need when it’s really dark outside or in the room you are monitoring — by adding a second set of infrared lights to the camera.

Other new features are an 80dB siren to deter unwanted visitors. This feature is triggered by Wyze’s AI-powered person-detection capability, but that’s a feature the company recently moved behind its $2/month CamPlus paywall, after originally offering it for free. That’s not going to break the bank (and you get a generous free trial period), but it’d be nice if the company could’ve kept this relatively standard feature free and instead only charged for extra cloud storage or more advanced features (though you do get free 14-day rolling cloud storage for 12-second clips).

Wyze Cam V2 (left) and V3 (right).

Wyze provided me with a review unit ahead of today’s launch (and a Cam V2 to compare them). The image quality of the new camera is clearly better and the larger field of view makes a difference, even though the distortion at the edges is a bit more noticeable now (but given the use case, that’s not an issue). The new night color vision mode works as promised and I like that you can set the camera to automatically switch between them based on the lighting conditions.

The person detection has been close to 100% accurate — and unlike some competing cameras that don’t feature this capability, I didn’t get any false alarms during rain or when the wind started blowing leaves across the ground.

If you already have a Wyze Cam V2, you don’t need to upgrade to this new one — the core features haven’t changed all that much, after all. But if you’re in the market for this kind of camera and aren’t locked into a particular security system, it’s hard to beat the new Wyze Cam.

technology

via TechCrunch https://techcrunch.com

October 27, 2020 at 01:08PM

MagSafe 15W fast charging restricted to Apple 20W adapter

https://ift.tt/2Tup1FS

macintosh

via AppleInsider https://ift.tt/3dGGYcl

October 26, 2020 at 08:38PM

Comic for October 27, 2020

https://ift.tt/3dXAC9R

fun

via Dilbert Daily Strip http://dilbert.com

October 27, 2020 at 01:52AM

Device Tracking in Laravel

https://ift.tt/3otT1jj

use IvanoMatteo\LaravelDeviceTracking\Traits\UseDevices;

class User extends Authenticatable
{

    use HasFactory, Notifiable, UseDevices;
    // ...
}

$user->device()

use IvanoMatteo\LaravelDeviceTracking\LaravelDeviceTrackingFacade as DeviceTracker;

DeviceTracker::detectFindAndUpdate();

DeviceTracker::flagCurrentAsVerified();

// Flag as verified for the current user
DeviceTracker::flagCurrentAsVerified();

// Flag as verified for a specific user
DeviceTracker::flagAsVerified($device, $user_id);

// Flag as verified for a specific user by device UUID
DeviceTracker::flagAsVerifiedByUuid($device_uuid, $user_id);

programming

via Laravel News https://ift.tt/14pzU0d

October 27, 2020 at 09:22AM

Memes that made me laugh 29

https://ift.tt/3ms69U7

Gathered up over the past week on the Internet.

More next week!

Peter

non critical

via Bayou Renaissance Man https://ift.tt/1ctARFa

October 26, 2020 at 05:59AM

Stack Abuse: What Does if __name__ == “__main__”: Do in Python?

https://ift.tt/37IeoYk

Introduction

It’s common to see if __name__ == "__main__" in Python scripts we find online, or one of the many we write ourselves.

Why do we use that if-statement when running our Python programs? In this article, we explain the mechanics behind its usage, the advantages, and where it can be used.

The __name__ Attribute and the __main__ Scope

The __name__ attribute comes by default as one of the names in the current local scope. The Python interpreter automatically adds this value when we are running a Python script or importing our code as a module.

Try out the following command on your Python interpreter. You may find out that __name__ belongs to the list of attributes in dir():

dir()

The __name__ in Python is a special variable that defines the name of the class or the current module or the script from which it gets invoked.

Create a new folder called name_scripts so we can write a few scripts to understand how this all works. In that folder create a new file, script1.py with the following code:

print(f'The __name__ from script1 is "{__name__}"')

That’s a curveball! We’d expect that the name would be script1, as our file. What does the output __main__ mean?

By default, when a script is executed, the interpreter reads the script and assigns the string __main__ to the __name__ keyword.

It gets even more interesting when the above script gets imported to another script. Consider a Python file named script2.py with the following code:

import script1  # The print statement gets executed upon import

print(f'The __name__ from script2 is "{__name__}"')

As you can see, when the script is executed the output is given as script1 denoting the name of the script. The final print statement is in the scope of script2 and when it gets executed, the output gets printed as: __main__.

Now that we understand how Python uses the __name__ scope and when it gives it a value of "__main__", let’s look at why we check for its value before executing code.

if __name__ == "__main__" in Action

We use the if-statement to run blocks of code only if our program is the main program executed. This allows our program to be executable by itself, but friendly to other Python modules who may want to import some functionality without having to run the code.

Consider the following Python programs:

a) script3.py contains a function called add() which gets invoked only from the main context.

def add(a, b):
    return a+b


if __name__ == "__main__":
    print(add(2, 3))

Here’s the output when script3.py gets invoked:

As the script was executed directly, the __name__ keyword is assigned to __main__, and the block of code under the if __name__ == "__main__" condition is executed.

b) Here’s what happens when this snippet is imported from script4.py:

import script3

print(f"{script3.__name__}")

The block under if __name__ == "__main__" from script3.py did not execute, as expected. This happened because the __name__ keyword is now assigned with the name of the script: script3. This can be verified by the print statement given which prints the assigned value for the __name__ keyword.

How Does __name__ == "__main__" Help in Development?

Here are some use cases for using that if-statement when creating your script

• Testing is a good practice which helps not only catch bugs but ensure your code behaves as required. Test files have to import a function or object to them. In these cases, we typically don’t want the script being run as the main module.
• You’re creating a library but would like to include a demo or other special run-time cases for users. By using this if-statement, the Python modules that use your code as a library are unaffected.

Creating a __main__.py File for Modules

The point of having the if __name__ == "__main__" block is to get the piece of code under the condition to get executed when the script is in the __main__ scope. While creating packages in Python, however, it’s better if the code to be executed under the __main__ context is written in a separate file.

Let’s consider the following example – a package for performing calculations. The file tree structure for such a scenario can be visualized as:

calc                 # --> Root directory
├── __main__.py
├── script1.py
├── script2.py
├── script3.py
├── script4.py
└── src              # --> Sub-directory
    ├── add.py
    └── sub.py

The tree structure contains calc as the root directory and a sub-directory known as src. The __main__.py under the calc directory contains the following content:

from src.add import add
from src.sub import sub

a, b = input("Enter two numbers separated by commas: ").split(',')
a, b = int(a), int(b)

print(f"The sum is: {add(a, b)}")
print(f"The difference is: {sub(a, b)}")

The add.py contains:

def add(a, b):
    return a+b

And sub.py contains:

def sub(a, b):
    return a-b

From right outside the calc directory, the script can be executed and the logic inside the __main__.py gets executed by invoking:

python3 calc

This structure also gives a cleaner look to the workspace location, the way how the directories are organized, and the entry point is defined inside a separate file called __main__.py.

Conclusion

The __name__ == "__main__" runs blocks of code only when our Python script is being executed directly from a user. This is powerful as it allows our code to have different behavior when it’s being executed as a program instead of being imported as a module.

When writing large modules, we can opt for the more structured approach of having a __main__.py file to run a module. For a stand-alone script, including the if __name__ == "__main__" is a simpler method to separate the API from the program.

Python

via Planet Python https://ift.tt/1dar6IN

October 26, 2020 at 09:50AM

Why the iPhone 12 Pro is worth the upgrade cost

https://ift.tt/31EV7TN

macintosh

via AppleInsider https://ift.tt/3dGGYcl

October 26, 2020 at 01:18PM

The Most Flammable Dust

https://ift.tt/3jsZOWJ

Link

You wouldn’t think that something as innocuous as corn starch could cause a massive fireball, but you’d be wrong. The Beyond the Press channel conducted a series of experiments to show just how flammable various kinds of dust and powder can be when exposed to a flame. They didn’t try non-dairy creamer though.

fun

via The Awesomer https://theawesomer.com

October 26, 2020 at 02:45PM

The No-Code Generation is arriving

https://ift.tt/3kuyetu

In the distant past, there was a proverbial “digital divide” that bifurcated workers into those who knew how to use computers and those who didn’t.[1] Young Gen Xers and their later millennial companions grew up with Power Macs and Wintel boxes, and that experience made them native users on how to make these technologies do productive work. Older generations were going to be wiped out by younger workers who were more adaptable to the needs of the modern digital economy, upending our routine notion that professional experience equals value.

Of course, that was just a narrative. Facility with using computers was determined by the ability to turn it on and login, a bar so low that it can be shocking to the modern reader to think that a “divide” existed at all. Software engineering, computer science, and statistics remained quite unpopular compared to other academic programs, even in universities, let alone in primary through secondary schools. Most Gen Xers and millennials never learned to code, or frankly, even to make a pivot table or calculate basic statistical averages.

There’s a sociological change underway though, and it’s going to make the first divide look quaint in hindsight.

Over the past two or so years, we have seen the rise of a whole class of software that has been broadly (and quite inaccurately) dubbed “no-code platforms.” These tools are designed to make it much easier for users to harness the power of computing in their daily work. That could be everything from calculating the most successful digital ad campaigns given some sort of objective function, or perhaps integrating a computer vision library into a workflow that calculates the number of people entering or exiting a building.

The success and notoriety of these tools comes from the feeling that they grant superpowers to their users. Projects that once took a team of engineers some hours to build can now be stitched together in a couple of clicks through a user interface. That’s why young startups like Retool can raise at nearly a $1 billion and Airtable at $2.6 billion, while others like Bildr, Shogun, Bubble, Stacker, and dozens more are getting traction among users.

Of course, no-code tools often require code, or at least, the sort of deductive logic that is intrinsic to coding. You have to know how to design a pivot table, or understand what a machine learning capability is and what might it be useful for. You have to think in terms of data, and about inputs, transformations, and outputs.

The key here is that no-code tools aren’t successful just because they are easier to use — they are successful because they are connecting with a new generation who understands precisely the sort of logic required by these platforms to function. Today’s students don’t just see their computers and mobile devices as consumption screens and have the ability to turn them on. They are widely using them as tools of self-expression, research and analysis.

Take the popularity of platforms like Roblox and Minecraft. Easily derided as just a generation’s obsession with gaming, both platforms teach kids how to build entire worlds using their devices. Even better, as kids push the frontiers of the toolsets offered by these games, they are inspired to build their own tools. There has been a proliferation of guides and online communities to teach kids how to build their own games and plugins for these platforms (Lua has never been so popular).

These aren’t tiny changes. 150 million play Roblox games across 40 million user-created experiences, and the platform has nearly 350,000 developers. Minecraft for its part has more than 130 million active users. These are generation-defining experiences for young people today.

That excitement to harness computers is also showing up in educational data. Advanced Placement tests for Computer Science have grown from around 20,000 in 2010 to more than 70,000 this year according to the College Board, which administers the high school proficiency exams. That’s the largest increase among all of the organization’s dozens of tests. Meanwhile at top universities, computer science has emerged as the top or among the top majors, pulling in hundreds of new students per campus per year.

The specialized, almost arcane knowledge of data analysis and engineering is being widely democratized for this new generation, and that’s precisely where a new digital divide is emerging.

In business today, it’s not enough to just open a spreadsheet and make some casual observations anymore. Today’s new workers know how to dive into systems, pipe different programs together using no-code platforms, and answer problems with much more comprehensive — and real-time — answers.

It’s honestly striking to see the difference. Whereas just a few years ago, a store manager might (and strong emphasis on might) put their sales data into Excel and then let it linger there for the occasional perusal, this new generation is prepared to connect multiple online tools together to build an online storefront (through no-code tools like Shopify or Squarespace), calculate basic LTV scores using a no-code data platform, and prioritize their best customers with marketing outreach through basic email delivery services. And it’s all reproducible, since it is in technology and code and not produced by hand.

There are two important points here. First is to note the degree of fluency these new workers have for these technologies, and just how many members of this generation seem prepared to use them. They just don’t have the fear to try new programs out, and they know they can always use search engines to find answers to problems they are having.

Second, the productivity difference between basic computer literacy and a bit more advanced expertise is profound. Even basic but accurate data analysis on a business can raise performance substantially compared to gut instinct and expired spreadsheets.

This second digital divide is only going to get more intense. Consider students today in school, who are forced by circumstance to use digital technologies in order to get their education. How many more students are going to become even more capable of using these technologies? How much more adept are they going to be at remote work? While the current educational environment is a travesty and deeply unequal, the upshot is that ever more students are going to be forced to become deeply fluent in computers.[2]

Progress in many ways is about raising the bar. This generation is raising the bar on how data is used in the workplace, in business, and in entrepreneurship. They are better than ever at bringing together various individual services and cohering them into effective experiences for their customers, readers, and users. The No-Code Generation has the potential to finally fill that missing productivity gap in the global economy, making our lives better while saving time for everyone.

[1] Probably worth pointing out that the other “digital divide” at the time was describing households who had internet access and households who did not. That’s a divide that unfortunately still plagues America and many other rich, industrialized countries.

[2] Important to note that access to computing is still an issue for many students and represents one of the most easily fixable inequalities today in America. Providing equal access to computing should be an absolute imperative.

technology

via TechCrunch https://techcrunch.com

October 26, 2020 at 12:26PM

Using the new Upserts feature in the Laravel Query Builder

https://ift.tt/34vbNPw

collect($csvContacts)->each(function (array $row) {
    $contact = Contact::updateOrCreate(
        ['email' => $row['email']],
        ['name' => $row['name'], 'address' => $row['address']]
    );
});

collect($csvContacts)
    ->map(function (array $row) {
        return Arr::only($row, ['email', 'name', 'address']);
    })
    ->chunk(1000)
    ->each(function (Collection $chunk) {
        Contact::upsert($chunk, 'email');
    });

programming

via Laravel News Links https://ift.tt/2dvygAJ

October 25, 2020 at 08:18PM