Trump escalates his campaign against Chinese tech companies, Facebook extends work from home until the middle of 2021 and Netflix adds support for Hindi. Here’s your Daily Crunch for August 7, 2020. The big story: Trump signs orders banning US business with TikTok owner ByteDance and Tencent’s WeChat Both orders will take effect in 45 […]

During an Unpacked event that featured the announcement of five key new devices, the Galaxy Tab S7 didn’t get a ton of love. Understandable, perhaps. It doesn’t quite have the star power of the Note line, nor does it have the novelty of a new foldable or Bluetooth earbuds. Tablets in general just aren’t exciting […]

Welcome back to Human Capital (formerly known as Tech at Work), which looks at all things labor in tech. This week presented Uber and Lyft with a fresh labor lawsuit as a judge heard arguments from Uber, Lyft and lawyers on behalf of the people of California in a separate suit brought forth by California’s […]

I see far more research articles than I could possibly write up. This column collects the most interesting of those papers and advances, along with notes on why they may prove important in the world of tech and startups. This week: supercomputers take on COVID-19, beetle backpacks, artificial spiderwebs, the “overwhelming whiteness” of AI and […]

A federal judge has approved the Department of Justice’s efforts to end the Paramount Consent Decrees — 70-year-old court orders that prevented movie studios from engaging in a variety of anti-competitive behaviors, including ownership of movie theaters. U.S. District Court Judge Analisa Torres cited the rise of streaming services like Netflix as one of the […]

Early-stage startup founders who are embarking on a Series A fundraising round should consider this: their relationship with the members of their board might last longer than the average American marriage. In other words, who invests in a startup matters as much — or more — than the total capital they’re bringing with them. It’s […]

Leveraging data, hardware and biological solutions can help brick-and-mortar stores remain relevant and continue churning out cash.

pytest 6 is out. Specifically, 6.0.1, as of July 31. And there's lots to be excited about. Anthony Sottile joins the show to discuss features, improvements, documentation updates and more. Full release notes / changelog Some of what we talk about: How to update (at least, how I do it) Run your test suites with 5.4.3 or whatever the last version you were using Update to 6 Run again. Same output? Probably good. If there are any warnings, maybe fix those. You can also run with pytest -W error to turn warnings into errors. Then find out all the cool stuff you can do now New Features pytest now supports pyproject.toml files for configuration. but remember, toml syntax is different than ini files. mostly quotes are needed pytest now includes inline type annotations and exposes them to user programs. Most of the user-facing API is covered, as well as internal code. New command-line flags --no-header and --no-summary A warning is now shown when an unknown key is read from a config INI file. The --strict-config flag has been added to treat these warnings as errors. New required_plugins configuration option allows the user to specify a list of plugins, including version information, that are required for pytest to run. An error is raised if any required plugins are not found when running pytest. Improvements You can now pass output to things like less and head that close the pipe passed to them. thank you!!! Improved precision of test durations measurement. use --durations=10 -vv to capture and show durations Rich comparison for dataclasses and attrs-classes is now recursive. pytest --version now displays just the pytest version, while pytest --version --version displays more verbose information including plugins. --junitxml now includes the exception cause in the message XML attribute for failures during setup and teardown. Improved Documentation Add a note about --strict and --strict-markers and the preference for the latter one. Explain indirect parametrization and markers for fixtures. Bug Fixes Deprecations Trivial/Internal Changes Breaking Changes you might need to care about before upgrading PytestDeprecationWarning are now errors by default. Check the deprecations and removals page if you are curious. -k and -m internals were rewritten to stop using eval(), this results in a few slight changes but overall makes them much more consistent testdir.run().parseoutcomes() now always returns the parsed nouns in plural form. I'd say that's an improvement Special Guest: Anthony Sottile.Sponsored By:Datadog: Modern monitoring & security. See inside any stack, any app, at any scale, anywhere. Visit testandcode.com/datadog to get started.Support Test & Code : Python Testing for Software EngineeringLinks:pytest Changelog / Release NotesDeprecations and Removals — pytest documentation<p>pytest 6 is out. Specifically, 6.0.1, as of July 31.<br><br> And there&#39;s lots to be excited about.<br> Anthony Sottile joins the show to discuss features, improvements, documentation updates and more.</p> <p><a href="https://docs.pytest.org/en/stable/changelog.html" rel="nofollow">Full release notes / changelog</a></p> <p>Some of what we talk about:</p> <ul> <li>How to update (at least, how I do it) <ul> <li>Run your test suites with 5.4.3 or whatever the last version you were using</li> <li>Update to 6</li> <li>Run again. Same output? Probably good.</li> <li>If there are any warnings, maybe fix those.</li> <li>You can also run with <code>pytest -W error</code> to turn warnings into errors.</li> <li>Then find out all the cool stuff you can do now</li> </ul></li> <li>New Features <ul> <li>pytest now supports pyproject.toml files for configuration. <ul> <li>but remember, toml syntax is different than ini files. mostly quotes are needed </li> </ul></li> <li>pytest now includes inline type annotations and exposes them to user programs. <ul> <li>Most of the user-facing API is covered, as well as internal code.</li> </ul></li> <li>New command-line flags <code>--no-header</code> and <code>--no-summary</code></li> <li>A warning is now shown when an unknown key is read from a config INI file. <ul> <li>The <code>--strict-config</code> flag has been added to treat these warnings as errors.</li> </ul></li> <li>New required_plugins configuration option allows the user to specify a list of plugins, including version information, that are required for pytest to run. An error is raised if any required plugins are not found when running pytest.</li> </ul></li> <li>Improvements <ul> <li>You can now pass output to things like less and head that close the pipe passed to them. <ul> <li>thank you!!!</li> </ul></li> <li>Improved precision of test durations measurement. <ul> <li>use <code>--durations=10 -vv</code> to capture and show durations</li> </ul></li> <li>Rich comparison for dataclasses and attrs-classes is now recursive.</li> <li>pytest <code>--version</code> now displays just the pytest version, <ul> <li>while <code>pytest --version --version</code> displays more verbose information including plugins. </li> </ul></li> <li><code>--junitxml</code> now includes the exception cause in the message XML attribute for failures during setup and teardown.</li> </ul></li> <li>Improved Documentation <ul> <li>Add a note about <code>--strict</code> and <code>--strict-markers</code> and the preference for the latter one.</li> <li>Explain indirect parametrization and markers for fixtures.</li> </ul></li> <li>Bug Fixes</li> <li>Deprecations</li> <li>Trivial/Internal Changes</li> <li>Breaking Changes you might need to care about before upgrading <ul> <li>PytestDeprecationWarning are now errors by default. <ul> <li>Check the <a href="https://docs.pytest.org/en/latest/deprecations.html" rel="nofollow">deprecations and removals</a> page if you are curious.</li> </ul></li> <li><code>-k</code> and <code>-m</code> internals were rewritten to stop using eval(), this results in a few <em>slight</em> changes but overall makes them much more consistent</li> <li><code>testdir.run().parseoutcomes()</code> now always returns the parsed nouns in plural form. <ul> <li>I&#39;d say that&#39;s an improvement</li> </ul></li> </ul></li> </ul><p>Special Guest: Anthony Sottile.</p><p>Sponsored By:</p><ul><li><a href="https://testandcode.com/datadog" rel="nofollow">Datadog</a>: <a href="https://testandcode.com/datadog" rel="nofollow">Modern monitoring & security. See inside any stack, any app, at any scale, anywhere. Visit testandcode.com/datadog to get started.</a></li></ul><p><a href="https://www.patreon.com/testpodcast" rel="payment">Support Test & Code : Python Testing for Software Engineering</a></p><p>Links:</p><ul><li><a href="https://docs.pytest.org/en/stable/changelog.html" title="pytest Changelog / Release Notes" rel="nofollow">pytest Changelog / Release Notes</a></li><li><a href="https://docs.pytest.org/en/latest/deprecations.html" title="Deprecations and Removals — pytest documentation" rel="nofollow">Deprecations and Removals — pytest documentation</a></li></ul>

We have been spoiled to have Tim Ruscica, founder and star of the very informative and popular “Tech with Tim” YouTube channel, work on our team as a Software Engineering intern this summer! During his time here he implemented several features for our extension, including the much desired export notebook to HTML and PDF, as well as influence the discussion and design of other features we have been actively working on and shipping. We’re honored to have him spotlight a few of his favorite VS Code Python Extension features (not just those he worked on) in a recent video! Please check it out and give Tim some much deserved kudos!   If you’re interested in learning about something specific, follow the timestamps below! 00:22 – VSCode Python Setup 00:50 – Jupyter Notebooks 01:38 – Interactive Window 03:28 – Variable Explorer 04:41 – Run By Line 05:50 – Dataframe Viewer 06:10 – Notebook Exports 06:56 – Gather 08:28 – Pylance   Did Tim’s video give you an idea for a feature? Let us know here! The post Need an Intro to VS Code? Let Tech with Tim Help! appeared first on Python.

Introduction H2 is a lightweight database server written in Java. It can be embedded in Java applications, or run as a standalone server. In this tutorial, we'll review why H2 can be a good option for your projects. We'll also learn how to integrate H2 with Python by building a simple Flask API. The Features of H2 H2 was built with performance in mind. "H2 is a combination of: fast, stable, easy to use, and features". Although H2 is prominent mainly because it can be embedded in Java applications, it has some interesting features that also apply to its server version. Let's see some of them next. Size and Performance The .jar file used for the server version is around 2MB. We can download it from the H2 site, bundled with extra scripts and documentation. If we search in Maven Central though, we can download the .jar file on its own. H2 performance shines in its embedded version. Even so, the official benchmark shows that its client-server version is also impressive. In-Memory Databases and Encryption In-Memory databases are not persistent. All data is stored in memory, so speed is greatly increased. The H2 site explains that In-Memory databases are particularly useful when prototyping, or when using read-only databases. Encryption is another useful feature to protect data at rest. Databases can be encrypted with the AES-128 algorithm. Other Useful Features H2 also provides a cluster mode, the ability to run multiple servers and connect them together. Writes are done in all servers at the same time, while reads are done from the first server in the cluster. H2 surprises for its simplicity. It provides several useful features and it's easy to set up. Let's start an H2 server in preparation for the following sections: $ java -cp ./h2-1.4.200.jar org.h2.tools.Server -tcp -tcpAllowOthers -tcpPort 5234 -baseDir ./ -ifNotExists The arguments that start with tcp enable communication to the server. The ifNotExists argument allows the database to be created when accessing it for the first time. Description of the API and General Diagram Let's suppose we are writing an API to register all exoplanets found to date. Exoplanets are planets found outside our Solar System, orbiting other stars. This is our simple API definition, a CRUD for one resource: This definition along with the rest of the code we'll see next is available in this GitHub repo. This is how our application will look like at the end of this tutorial: Left of the diagram we see the API Client. That client can be the "Try it out" function of the Swagger Editor, or any other client, like Postman or cURL. On the other end we find the H2 database server, running on TCP port 5234 as explained above. Finally, our application in the middle is composed of three Python files. The first one will have the Flask app that will answer all REST API requests. All endpoints we described in the definition above will be added to this file. The second file will have the persistence, functions that access the database to execute the CRUD operations, using the JayDeBeApi package. Lastly, a third file will contain a schema representing the resource the API manages, the Exoplanet. We'll use the Marshmallow package to represent that schema. The first two python files will use this schema to represent resources and pass them to each other. Let's start off with the persistence file. Database Schema To store the Exoplanet resource to an H2 database we should write the basic CRUD functions first. Let's start by writing the creation of the database. We use the JayDeBeApi package to access databases through JDBC: import jaydebeapi def initialize(): _execute( ("CREATE TABLE IF NOT EXISTS exoplanets (" " id INT PRIMARY KEY AUTO_INCREMENT," " name VARCHAR NOT NULL," " year_discovered SIGNED," " light_years FLOAT," " mass FLOAT," " link VARCHAR)")) def _execute(query, returnResult=None): connection = jaydebeapi.connect( "org.h2.Driver", "jdbc:h2:tcp://localhost:5234/exoplanets", ["SA", ""], "../h2-1.4.200.jar") cursor = connection.cursor() cursor.execute(query) if returnResult: returnResult = _convert_to_schema(cursor) cursor.close() connection.close() return returnResult The initialize() function is simple enough because of the helper functions after. It creates the exoplanets table if it doesn't exist already. This function should be executed before our API starts receiving requests. We'll see later where to do that with Flask. The _execute() function contains the connection string and credentials to access the database server. It is simpler for this example, but there is room for improvement regarding security. We could save our credentials elsewhere, like environment variables for example. Also, we added the path to the H2 jar file to the connect() method, as it has the driver we need to connect to H2 - org.h2.Driver. The JDBC connection string ends in /exoplanets. This means that when connecting for the first time a database called exoplanets will be created. You may have noticed that _execute() can return the result of the SQL query using the _convert_to_schema() function. Let's now see how that function works. Marshmallow Schemas and CRUD Database Functions Some SQL queries return tabular results, particularly the SELECT statement. JayDeBeApi will format those results as a list of tuples. For example, for the schema defined in the last section we could get a result similar to this: >>> connection = jaydebeapi.connect(... >>> cursor = connection.cursor() >>> cursor.execute("SELECT * FROM exoplanets") >>> cursor.fetchall() [(1, 'Sample1', 2019, 4.5, 1.2, 'http://sample1.com')] Nothing's stopping us from managing results in this format and eventually return it to the API client. But looking ahead we know we will use Flask, so it would be good to already return results in a format Flask recommends. In particular, we'll be using Flask-RESTful to facilitate the use of API routes. That package recommends to use Marshmallow to parse requests. This step allows for normalization of the objects. This way we can discard unknown properties and highlight validation errors, for example. Let's see how the Exoplanet class would look so we can discuss further: from marshmallow import Schema, fields, EXCLUDE class ExoplanetSchema(Schema): id = fields.Integer(allow_none=True) name = fields.Str(required=True, error_messages={"required": "An exoplanet needs at least a name"}) year_discovered = fields.Integer(allow_none=True) light_years = fields.Float(allow_none=True) mass = fields.Float(allow_none=True) link = fields.Url(allow_none=True) class Meta: unknown = EXCLUDE The definition of the properties looks familiar. It's the same as the database schema, including the definition of required fields. All fields have a type that defines some default validation. For example, the link field is defined as an URL, so a string that doesn't look like an URL won't be valid. Specific error messages can also be included here, like the validation for a name. For this example project, we want to discard, or exclude, all unknown fields and API client may send erroneously. This is achieved in the Meta nested class. Now we can use the load() and loads() Marshmallow methods to convert and validate our resources. Now that we're acquainted with Marshmallow, we can explain what the _convert_to_schema() does: def _convert_to_schema(cursor): column_names = [record[0].lower() for record in cursor.description] column_and_values = [dict(zip(column_names, record)) for record in cursor.fetchall()] return ExoplanetSchema().load(column_and_values, many=True) In JayDeBeApi, column names are saved in the description field of the cursor, while the data can be obtained with the fetchall() method. We used list comprehensions in the first two lines to get the column names and values, and zip() to merge them. The last line takes the merged result and converts them to ExoplanetSchema objects that Flask can further process. Now that we explained the _execute() function and the ExoplanetSchema class, let's see all the CRUD database functions: def get_all(): return _execute("SELECT * FROM exoplanets", returnResult=True) def get(Id): return _execute("SELECT * FROM exoplanets WHERE id = {}".format(Id), returnResult=True) def create(exoplanet): count = _execute("SELECT count(*) AS count FROM exoplanets WHERE name LIKE '{}'".format(exoplanet.get("name")), returnResult=True) if count[0]["count"] > 0: return columns = ", ".join(exoplanet.keys()) values = ", ".join("'{}'".format(value) for value in exoplanet.values()) _execute("INSERT INTO exoplanets ({}) VALUES({})".format(columns, values)) return {} def update(exoplanet, Id): count = _execute("SELECT count(*) AS count FROM exoplanets WHERE id = {}".format(Id), returnResult=True) if count[0]["count"] == 0: return values = ["'{}'".format(value) for value in exoplanet.values()] update_values = ", ".join("{} = {}".format(key, value) for key, value in zip(exoplanet.keys(), values)) _execute("UPDATE exoplanets SET {} WHERE id = {}".format(update_values, Id)) return {} def delete(Id): count = _execute("SELECT count(*) AS count FROM exoplanets WHERE id = {}".format(Id), returnResult=True) if count[0]["count"] == 0: return _execute("DELETE FROM exoplanets WHERE id = {}".format(Id)) return {} All functions are mainly SQL queries, but create() and update() deserve some more explanation. The INSERT SQL statement can receive column and values separated, in the form INSERT INTO table (column1Name) VALUES ('column1Value'). We can use the join() function to merge all columns and separate them with commas, and do something similar to join all values we want to insert. The UPDATE SQL statement is a bit more complex. Its form is UPDATE table SET column1Name = 'column1Value'. So we need to alternate keys and values, and we did it using the zip() function. All these functions return None when there is a problem. Later when we call them we will have to check for that value. Let's save all database functions on its own file, persistence.py, so we can add some context when we call the functions, like this: import persistence persistence.get_all() REST API With Flask Now that we wrote a layer to abstract the access to the database, we are ready to write the REST API. We'll use the Flask and Flask-RESTful packages to make our definition as easy as possible. As we learned before, we'll also use Marshmallow to validate resources. Flask-RESTful requires to define one class per API resource, in our case the Exoplanet resource only. Then we can associate that resource with a route like this: from flask import Flask from flask_restful import Resource, Api app = Flask(__name__) api = Api(app) class Exoplanet(Resource): # ... api.add_resource(Exoplanet, "/exoplanets", "/exoplanets/<int:Id>") This way all our routes, /exoplanets and /exoplanets/<int:Id> will be directed to the class we defined. For example, the GET /exoplanets endpoint will be answered by a method called get() inside the Exoplanet class. Because we also have the GET /exoplanet/<Id> endpoint, that get() method must have an optional parameter called Id. Let's see the whole class to understand this better: from flask import request from flask_restful import Resource, abort from marshmallow import ValidationError import persistence class Exoplanet(Resource): def get(self, Id=None): if Id is None: return persistence.get_all() exoplanet = persistence.get(Id) if not exoplanet: abort(404, errors={"errors": {"message": "Exoplanet with Id {} does not exist".format(Id)}}) return exoplanet def post(self): try: exoplanet = ExoplanetSchema(exclude=["id"]).loads(request.json) if not persistence.create(exoplanet): abort(404, errors={"errors": {"message": "Exoplanet with name {} already exists".format(request.json["name"])}}) except ValidationError as e: abort(405, errors=e.messages) def put(self, Id): try: exoplanet = ExoplanetSchema(exclude=["id"]).loads(request.json) if not persistence.update(exoplanet, Id): abort(404, errors={"errors": {"message": "Exoplanet with Id {} does not exist".format(Id)}}) except ValidationError as e: abort(405, errors=e.messages) def delete(self, Id): if not persistence.delete(Id): abort(404, errors={"errors": {"message": "Exoplanet with Id {} does not exist".format(Id)}}) The remaining HTTP verbs are processed in the same way as GET, by the methods with name post(), put() and delete() . As we said before, logic errors when accessing the database will cause the functions to return None. Those errors are captured here when needed. Also, exceptions that represent validation errors are triggered by Marshmallow, so those errors are also captured and returned to the user along with an appropriate return error. Conclusion H2 is a useful database server, performant and easy to use. Although it is a Java package, it can also run as a standalone server, so we can use it in Python with the JayDeBeApi package. In this tutorial we defined a simple CRUD application to illustrate how to access the database, and which functions are available. After that, we defined a REST API with Flask and Flask-RESTful. Although several concepts were omitted for the sake of brevity, like authentication and paging, this tutorial is a good reference to start using H2 in our Flask projects.

Do you want to learn the how and when of implementing K-means clustering in Python? Would you like to practice your pandas skills with a real-world project? This week on the show, David Amos is back with another batch of PyCoder’s Weekly articles and projects. [ Improve Your Python With ? Python Tricks ? – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

Hello everyone I know I am late for the weekly blog. My apologies for that. The previous week was my first week post my exams. I had mentioned in the last blog that I will be working on the documentation for panda3d. So, just as I mentioned, I was able to complete the documentation part in one week. The documentation includes documentation for both python and c++, the languages supported by panda3d for game development. The appropriate code snippets have been included along with the screenshots of the corresponding output. The challenges were to understand the reStructured text format by Sphinx ans write the code for documentation with proper identation and tags so as to build separate docs for python and c++. You may find the Pull Request here: #71 This week I am working on the sample code. Some part of work has been done and hopefully it will be completed by the weekend. I will share more about the same in my next blog. Thank you! Stay Safe!

The post [Video] How to Learn Python? (From Zero to Hero) appeared first on Afternerd.

Leverage DLLs from Python. Send faxes with Python without writing any code to send faxes.

Toggle Bolt Market: Intense Competition but High Growth & Extreme Valuation | Essentra Components, Western States Hardware, Fastener Technology  Chelanpress

Shrinking deep learning's carbon footprint  MIT News

Global Stainless Steel Railings Market (2020-2026) | Latest COVID19 Impact Analysis | Know About Brand Players: FH Brundle , GOKING HARDWARE , Inline Design , Halinox Steel Industries , Kamal Metal Industries | Worldwide Market  The Daily Chronicle

High Grade Furniture Market 2020 Business Scenario –Restoration Hardware, Ligne Roset, Hooker Furniture Corporation, Kimball Hospitality  eRealty Express

Trending now: Chain Door Guard Market Size, Share, Industry Trends, Growth Insight, Share, Competitive Analysis, Statistics, Regional, And Industry Forecast | Accent Builders Hardware, Baldwin, Belwith Products LLC, Deltana, Eight24hours  Chelanpress

Maingear Turbo Review: A Jaw-Dropping Mini-ITX Gaming PC  Hot Hardware

The new Lenovo connected PC and Workspot: Closing in on a cloud desktop future  Computerworld

New research from Check Point has revealed that Google and Amazon were were the most impersonated brands in Q2.

If you're looking to kill some time, these are the best online games you can play today.

Save a massive $90 with a free Echo Show 5 thrown in

We break down the pros and cons of signing up for identity theft protection and credit monitoring.

Want a large notebook with a big display? These are the top picks for 17-inch laptops.

Graphing calculators are essential tools for both students and scientific professionals to help visualize some pretty abstract math. But which is the best graphing calculator for your specific need?

This deal on HMA VPN will let you protect your web traffic and privacy for just $2.99/month.