Will McGugan has brought a lot of color to CLIs within Python due to Rich.
Then Textual started rethinking full command line applications, including layout with CSS.
And now Textualize, a new startup, is bringing CLI apps to the web.

Special Guest: Will McGugan.

Sponsored By:

• Rollbar: With Rollbar, developers deploy better software faster.

Links:

• rich
• rich-cli
• textual
• Textualize.io
• Rich Gallery
• Textualize Gallery
• Python Bytes Podcast

The Python standard library is full of underappreciated gems. One of them allows for simple and elegant function dispatching based on argument types. This makes it perfect for serialization of arbitrary objects – for example to JSON in web APIs and structured logs.

At EuroSciPy in 2018, Marc Garcia gave a lightning talk which started by pointing out that scientific Python programmers like to alias everything, such as

import numpy as np
import pandas as pd

and suggested that they perhaps would prefer to use emojis, such as

import pandas as 🐼

However, Python does not support emojis as code, so the above line cannot be used.

A year prior, Thomas A Caswell had created a pull request for CPython that would have made this possible. This code would have allowed the use of emojis in all environments, including in a Python REPL and even in Jupyter notebooks. Unsurprisingly, this was rejected.

Undeterred, Geir Arne Hjelle created a project called pythonji (available on Pypi) which enabled the use of emojis in Python code, but in a much more restricted way. With pythonji, one can run modules ending with 🐍 instead of .py from a terminal. However, such modules cannot be imported, nor can emojis be used in a terminal.

When I learned about this attempt by Geir Arne Hjelle from a tweet by Mike Driscoll, I thought it would be a fun little project to implement with ideas.  Below, I use the same basic example included in the original pythonji project.

And, it works in Jupyter notebooks too!

😉

I spoke at PyCon 2022 about writing safe, elegant concurrent Python with threads. The video is coming soon; here’s a written version of the talk. asyncio. Asyncio is really hip. And not just asyncio—the older async frameworks like Twisted and Tornado, and more recent ones like Trio and Curio are hip, too. I think they deserve to be! I’m a big fan. I spent a lot of time contributing to Tornado and asyncio some years ago.

We understand that the PyCon US recordings are an incredibly important resource to the community. We were looking forward to providing the PyCon US 2022 recordings very soon after the event – especially since we know many of you weren’t able to attend this year’s conference in person. Regrettably, we have encountered some technical obstacles this year. We are working with our AV partners at the venue to resolve things as soon as possible.

Because of the ongoing pandemic, we were unable to work with our usual vendor for PyCon US conferences. They are based in Canada and understandably didn’t want to commit to travel to the US this year. This resulted in PyCon US contracting with a new AV vendor for the first time in many years. We were very thorough in providing details, but ultimately this was a new team doing work to new specifications.

The onsite AV team has provided an update on the technical issues as follows: “Some of the sessions are missing audio or graphics and are being worked through. There is a backup drive of all the content that has been mailed to the editing team to hopefully resolve those that are missing graphics and/or audio.” We remain hopeful that everyone’s sessions will eventually be posted with all audio and graphics intact, but it is going to take more time than we would like.

Last week I attended OAuth Security Workshop at Trondheim, Norway. It was a 3-day single-track conference, where the first half of the days were pre-selected talks, and the second parts were unconference talks/side meetings. This was also my first proper conference after COVID emerged in the world.

Back to the starting line

After many years felt the whole excitement of being a total newbie in something and suddenly being able to meet all the people behind the ideas. I reached the conference hotel in the afternoon of day 0 and met the organizers as they were in the lobby area. That chat went on for a long, and as more and more people kept checking into the hotel, I realized that it was a kind of reunion for many of the participants. Though a few of them met at a conference in California just a week ago, they all were excited to meet again.

To understand how welcoming any community is, just notice how the community behaves towards new folks. I think the Python community stands high in this regard. And I am very happy to say the whole OAuth/OIDC/Identity-related community folks are excellent in this regard. Even though I kept introducing myself as the new person in this identity land, not even for a single time I felt unwelcome. I attended OpenID-related working group meetings during the conference, multiple hallway chats, or talked to people while walking around the beautiful city. Everyone was happy to explain things in detail to me. Even though most of the people there have already spent 5-15+ years in the identity world.

The talks & meetings

What happens in Trondheim, stays in Trondheim.

I generally do not attend many talks at conferences, as they get recorded. But here, the conference was a single track, and also, there were no recordings.

The first talk was related to formal verification, and this was the first time I saw those (scary in my mind) maths on the big screen. But, full credit to the speakers as they explained things in such a way so that even an average programmer like me understood each step. And after this talk, we jumped into the world of OAuth/OpenID. One funny thing was whenever someone mentioned some RFC number, we found the authors inside the meeting room.

In the second half, we had the GNAP master class from Justin Richer. And once again, the speaker straightforwardly explained such deep technical details so that everyone in the room could understand it.

Now, in the evening before, a few times, people mentioned that in heated technical details, many RFC numbers will be thrown at each other, though it was not that many for me to get too scared :)

I also managed to meet Roland for the first time. We had longer chats about the status of Python in the identity ecosystem and also about Identity Python. I took some notes about how we can improve the usage of Python in this, and I will most probably start writing about those in the coming weeks.

In multiple talks, researchers & people from the industry pointed out the mistakes made in the space from the security point of view. Even though, for many things, we have clear instructions in the SPECs, there is no guarantee that the implementors will follow them properly, thus causing security gaps.

At the end of day 1, we had a special Organ concert at the beautiful Trondheim Cathedral. On day 2, we had a special talk, “The Viking Kings of Norway”.

If you let me talk about my experience at the conference, I don’t think I will stop before 2 hours. It was so much excitement, new information, the whole feeling of going back into my starting days where I knew nothing much. Every discussion was full of learning opportunities (all discussions are anyway, but being a newbie is a different level of excitement) or the sadness of leaving Anwesha & Py back in Stockholm. This was the first time I was staying away from them after moving to Sweden.

Just before the conference ended, Aaron Parecki gave me a surprise gift. I spent time with it during the whole flight back to Stockholm.

This conference had the best food experience of my life for a conference. Starting from breakfast to lunch, big snack tables, dinners, or restaurant foods. In front of me, at least 4 people during the conference said, “oh, it feels like we are only eating and sometimes talking”.

Another thing I really loved to see is that the two primary conference organizers are university roommates who are continuing the friendship and journey in a very beautiful way. After midnight, standing outside of the hotel and talking about random things about life and just being able to see two longtime friends excited about similar things, it felt so nice.

I also want to thank the whole organizing team, including local organizers, Steinar, and the rest of the team did a superb job.

How can you read binary files in Python? And how can you read very large binary files in small chunks?

Table of contents

1. How to read a binary file in Python
2. Use a library to read your binary file
3. Working at byte level in Python
4. Reading binary files in chunks
5. Aside: using an assignment expression
6. Summary

>>> with open("exercises.zip") as zip_file:
...     contents = zip_file.read()
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "/usr/lib/python3.10/codecs.py", line 322, in de
code
    (result, consumed) = self._buffer_decode(data, self.errors, final)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x8e in position 11: invalid sta
rt byte

>>> with open("exercises.zip") as zip_file:
...     contents = zip_file.read()
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "/usr/lib/python3.10/codecs.py", line 322, in de
code
    (result, consumed) = self._buffer_decode(data, self.errors, final)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x8e in position 11: invalid sta
rt byte

>>> with open("exercises.zip", mode="rb") as zip_file:
...     contents = zip_file.read()
...

>>> with open("exercises.zip", mode="rb") as zip_file:
...     contents = zip_file.read()
...

>>> with open("exercises.zip", mode="rb") as zip_file:
...     contents = zip_file.read()
...
>>> type(contents)
<class 'bytes'>
>>> contents[:20]
b'PK\x03\x04\n\x00\x00\x00\x00\x00Y\x8e\x84T\x00\x00\x00\x00\x00\x00'

>>> with open("exercises.zip", mode="rb") as zip_file:
...     contents = zip_file.read()
...
>>> type(contents)
<class 'bytes'>
>>> contents[:20]
b'PK\x03\x04\n\x00\x00\x00\x00\x00Y\x8e\x84T\x00\x00\x00\x00\x00\x00'

Read the full article: https://www.pythonmorsels.com/reading-binary-files-in-python/

Read the full article at https://realpython.com/linear-regression-in-python/ »

[ 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 ]

Sets are used to store unique objects. Sometimes, we might need to find the elements in a set that are not present in another given set. For this, we use the set difference operation. In this article, we will discuss what is set difference is. We will also discuss approaches to find the set difference in python.

What is the Set Difference?

When we are given two sets A and B. The set difference (A-B) is a set consisting of all the elements that belong to A but are not present in set B. 

Similarly, the set difference (B-A) is a set consisting of all the elements that belong to B but are not present in set A. 

Consider the following sets.

A={1,2,3,4,5,6,7}

B={5,6,7,8,9,10,11}

Here, set A-B will contain the elements 1,2,3, and 4 as these elements are present in set A but do not belong to set B. Similarly, set B-A will contain the elements 8,9,10,11 as these elements are present in the set B but do not belong to set A .

Let us now discuss approaches to find set difference in python. 

How to Find The Set Difference in Python?

Given the sets A and B, if we want to find the the set difference A-B, we will first create an empty set named output_set. After that, we will traverse set A using a for loop. While traversal, we will check for each element if they are present in the set B or not. If any element in set A doesn’t belong to the set B, we will add the element to the output_set using the add() method. 

After execution of the for loop, we will get the set difference A-B in the output_set. You can observe this in the following example.

A = {1, 2, 3, 4, 5, 6, 7}
B = {5, 6, 7, 8, 9, 10, 11}
output_set = set()
for element in A:
    if element not in B:
        output_set.add(element)
print("The set A is:", A)
print("The set B is:", B)
print("The set A-B is:", output_set)

Output:

The set A is: {1, 2, 3, 4, 5, 6, 7}
The set B is: {5, 6, 7, 8, 9, 10, 11}
The set A-B is: {1, 2, 3, 4}

If we want to find the the set difference B-A, we will traverse set B using a for loop. While traversal, we will check for each element if they are present in the set A or not. If any element in set B doesn’t belong to the set A, we will add the element to the output_set using the add() method. 

After execution of the for loop, we will get the set difference B-A in the output_set. You can observe this in the following example.

A = {1, 2, 3, 4, 5, 6, 7}
B = {5, 6, 7, 8, 9, 10, 11}
output_set = set()
for element in B:
    if element not in A:
        output_set.add(element)
print("The set A is:", A)
print("The set B is:", B)
print("The set B-A is:", output_set)

Output:

The set A is: {1, 2, 3, 4, 5, 6, 7}
The set B is: {5, 6, 7, 8, 9, 10, 11}
The set B-A is: {8, 9, 10, 11}

Find Set Difference Using The difference() Method in Python

Python provides us with the difference() method to find the set difference. The difference() method, when invoked on set A, takes  set B as input argument, calculates the set difference, and returns a set containing the elements in the set (A-B). You can observe this in the following example.

A = {1, 2, 3, 4, 5, 6, 7}
B = {5, 6, 7, 8, 9, 10, 11}
output_set = A.difference(B)
print("The set A is:", A)
print("The set B is:", B)
print("The set A-B is:", output_set)

Output:

The set A is: {1, 2, 3, 4, 5, 6, 7}
The set B is: {5, 6, 7, 8, 9, 10, 11}
The set A-B is: {1, 2, 3, 4}

Conclusion

In this article, we have discussed how to find the set difference in python. To learn more about sets, you can read this article on set comprehension in python. You might also like this article on list comprehension in python.

The post Set Difference in Python appeared first on PythonForBeginners.com.

This week we welcome Raza Zaidi (@razacodes) as our PyDev of the Week! Raza is a content creator on Twitter and YouTube. You can learn about Python, data science, Django, and more on Raza's YouTube channel. Check it out when you get a chance!

Now let's spend a few moments getting to know Raza better!

Can you tell us a little about yourself (hobbies, education, etc):

Hi I’m Raza, Head of Dev Rel at thirdweb. An accountant by profession, but technology enthusiast by heart. Wildly passionate about emerging technologies and educating about them. I consider myself a below average developer and the walking proof that anyone can learn how to develop. Currently I’m focused on teaching developers on how to get started in Web3 through his Twitter, Tiktok and YouTube channel. By no means do I think that Python is the best programming language out there. In my spare time, I love to binge-watch anime.

Why did you start using Python?

I used to be head of a Data engineering platform and honestly I thought all these devs were so cool. I just started to hang out with the devs and asked them to use me as a test bunny. I learned how to spin up environments and run basic Python scripts and that’s how I got started with Python.

What other programming languages do you know and which is your favorite?

I know a bit javascript and solidity. I like solidity, but nothing beats Python.

What projects are you working on now?

A couple. I think Python is tremendously underrepresented in the web3 space. There are so many cool libraries and I’m working on content to bring more awareness. Besides that I’m diving into the beginner space again, a platform to help more people get started with Python.  Stay tuned!

Which Python libraries are your favorite (core or 3rd party)?

1. Pandas
2. Turtle (I love drawing in Python!)
3. thirdweb’s sdk

How did you decide to become a content creator?

I guess I look at myself as a really bad programmer and use that power to simplify concepts for myself to understand. Then I just share that information. So it wasn’t a conscious decision, I kind of rolled into it.

What challenges have you had as a content creator and how did you overcome them?

I guess finding new ideas and structure. I’m learning a lot by engaging in the community and I need to do that more. But that’s great way to get inspiration.

Is there anything else you’d like to say?

Please reach out if you also want to spread the message about Python. I’m looking for like minded devs who want to contribute to beginner content and to help people get started to develop in Python!

Thanks for doing the interview, Raza!

The post PyDev of the Week: Raza (Rython) Zaidi appeared first on Mouse Vs Python.

Numpy is one of the most used module in Python and it is used in a variety of tasks ranging from creating array to mathematical and statistical calculations. Numpy also bring efficiency in Python programming. While using numpy you may encounter this error TypeError: only size-1 arrays can be converted to Python scalars It is one of the frequently appearing error and sometimes it becomes a daunting challenge to solve it.

Meaning : Only Size 1 Arrays Can Be Converted To Python Scalars Error

There are 5 method to solve this error

import numpy as np
x = np.array([2, 3.5, 4, 5.3, 27])

np.int(x)

x.astype(int)

array([ 2,  3,  4,  5, 27])

x = x.astype(int)

I was looking to get a little done on the ethereum-classic-taxman accounting tool today, and thought a bit outside-the-box, what could I need in there that isn't a direct priority.

The tool uses JSON databases, I switched a little while back because there could be security issues related to using a Python pickle database as the database backend.

An added benefit of using JSON is that its content is easy to view, and for example for debugging purposes, I thought it could be a good thing to have a tool that creates a view of the data that is easy to navigate and view. For example for debug purposes.

So I created this little script:

https://github.com/morphex/ethereum-classic-taxman/blob/main...

There are graphical JSON viewers on Ubuntu for example, but this little script can also have its output piped into a file, so that a database can be edited by hand in an editor. Or it could be piped to less on Linux/UNIX for viewing and searching.

On a related note, I saw some people lost their savings on the recent Luna/Terra crash. On the upside, I guess now is a chance to make a bet that the new variant with a massively higher amount of coins minted will succeed.

Digital cameras and the widespread availability of smartphones has allowed us all to generate massive libraries of personal photographs. Unfortunately, now we are all left to our own devices of how to manage them. While cloud services such as iPhotos and Google Photos are convenient, they aren't always affordable and they put your pictures under the control of large companies with their own agendas. LibrePhotos is an open source and self-hosted alternative to these services that puts you in control of your digital memories. In this episode the maintainer of LibrePhotos, Niaz Faridani-Rad, explains how he got involved with the project, the capabilities that it offers for managing your image library, and how to get your own instance set up to take back control of your pictures.

Overview

Continuing in the series of articles about newest cloud connections in Zato 3.2, this episode covers Atlassian Jira from the perspective of invoking its APIs to build integrations between Jira and other systems.

There are essentially two use modes of integrations with Jira:

1. Jira reacts to events taking place in your projects and invokes your endpoints accordingly via WebHooks. In this case, it is Jira that explicitly establishes connections with and sends requests to your APIs.
2. Jira projects are queried periodically or as a consequence of events triggered by Jira using means other than WebHooks.

The first case is usually more straightforward to conceptualize - you create a WebHook in Jira, point it to your endpoint and Jira invokes it when a situation of interest arises, e.g. a new ticket is opened or updated. I will talk about this variant of integrations with Jira in a future instalment as the current one is about the other situation, when it is your systems that establish connections with Jira.

The reason why it is more practical to first speak about the second form is that, even if WebHooks are somewhat easier to reason about, they do come with their own ramifications.

To start off, assuming that you use the cloud-based version of Jira (e.g. https://example.atlassian.net), you need to have a publicly available endpoint for Jira to invoke through WebHooks. Very often, this is undesirable because the systems that you need to integrate with may be internal ones, never meant to be exposed to public networks.

Secondly, your endpoints need to have a TLS certificate signed by a public Certificate Authority and they need to be accessible on port 443. Again, both of these are something that most enterprise systems will not allow at all or it may take months or years to process such a change internally across the various corporate departments involved.

Lastly, even if a WebHook can be used, it is not always a given that the initial information that you receive in the request from a WebHook will already contain everything that you need in your particular integration service. Thus, you will still need a way to issue requests to Jira to look up details of a particular object, such as tickets, in this way reducing WebHooks to the role of initial triggers of an interaction with Jira, e.g. a WebHook invokes your endpoint, you have a ticket ID on input and then you invoke Jira back anyway to obtain all the details that you actually need in your business integration.

The end situation is that, although WebHooks are a useful concept that I will write about in a future article, they may very well not be sufficient for many integration use cases. That is why I start with integration methods that are alternative to WebHooks.

Alternatives to WebHooks

If, in our case, we cannot use WebHooks then what next? Two good approaches are:

1. Scheduled jobs
2. Reacting to emails (via IMAP)

Scheduled jobs will let you periodically inquire with Jira about the changes that you have not processed yet. For instance, with a job definition as below:

Now, the service configured for this job will be invoked once per minute to carry out any integration works required. For instance, it can get a list of tickets since the last time it ran, process each of them as required in your business context and update a database with information about what has been just done - the database can be based on Redis, MongoDB, SQL or anything else.

Integrations built around scheduled jobs make most sense when you need to make periodic sweeps across a large swaths of business data, these are the “Give me everything that changed in the last period” kind of interactions when you do not know precisely how much data you are going to receive.

In the specific case of Jira tickets, though, an interesting alternative may be to combine scheduled jobs with IMAP connections:

The idea here is that when new tickets are opened, or when updates are made to existing ones, Jira will send out notifications to specific email addresses and we can take advantage of it.

For instance, you can tell Jira to CC or BCC an address such as zato@example.com. Now, Zato will still run a scheduled job but instead of connecting with Jira directly, that job will look up unread emails for it inbox (“UNSEEN” per the relevant RFC).

Anything that is unread must be new since the last iteration which means that we can process each such email from the inbox, in this way guaranteeing that we process only the latest updates, dispensing with the need for our own database of tickets already processed. We can extract the ticket ID or other details from the email, look up its details in Jira and the continue as needed.

All the details of how to work with IMAP emails are provided in the documentation but it would boil down to this:

# -*- coding: utf-8 -*-

# Zato
from zato.server.service import Service

class MyService(Service):

    def handle(self):
        conn = self.email.imap.get('My Jira Inbox').conn

        for msg_id, msg in conn.get():

            # Process the message here ..
            process_message(msg.data)

            # .. and mark it as seen in IMAP.
            msg.mark_seen()

The natural question is - how would the “process_message” function extract details of a ticket from an email?

There are several ways:

1. Each email has a subject of a fixed form - “[JIRA] (ABC-123) Here goes description”. In this case, ABC-123 is the ticket ID.
2. Each email will contain a summary, such as the one below, which can also be parsed:

         Summary: Here goes description
             Key: ABC-123
             URL: https://example.atlassian.net/browse/ABC-123
         Project: My Project
      Issue Type: Improvement
Affects Versions: 1.3.17
     Environment: Production
        Reporter: Reporter Name
        Assignee: Assignee Name

3. Finally, each email will have an “X-Atl-Mail-Meta” header with interesting metadata that can also be parsed and extracted:

X-Atl-Mail-Meta: user_id="123456:12d80508-dcd0-42a2-a2cd-c07f230030e5",
                 event_type="Issue Created",
                 tenant="https://example.atlassian.net"

The first option is the most straightforward and likely the most convenient one - simply parse out the ticket ID and call Jira with that ID on input for all the other information about the ticket. How to do it exactly is presented in the next chapter.

Regardless of how we parse the emails, the important part is that we know that we invoke Jira only when there are new or updated tickets - otherwise there would not have been any new emails to process. Moreover, because it is our side that invokes Jira, we do not expose our internal system to the public network directly.

However, from the perspective of the overall security architecture, email is still part of the attack surface so we need to make sure that we read and parse emails with that in view. In other words, regardless of whether it is Jira invoking us or our reading emails from Jira, all the usual security precautions regarding API integrations and accepting input from external resources, all that still holds and needs to be part of the design of the integration workflow.

Creating Jira connections

The above presented the ways in which we can arrive at the step of when we invoke Jira and now we are ready to actually do it.

As with other types of connections, Jira connections are created in Zato Dashboard, as below. Note that you use the email address of a user on whose behalf you connect to Jira but the only other credential is that user’s API token previously generated in Jira, not the user’s password.

Invoking Jira

With a Jira connection in place, we can now create a Python API service. In this case, we accept a ticket ID on input (called “a key” in Jira) and we return a few details about the ticket to our caller.

This is the kind of a service that could be invoked from a service that is triggered by a scheduled job. That is, we would separate the tasks, one service would be responsible for opening IMAP inboxes and parsing emails and the one below would be responsible for communication with Jira.

Thanks to this loose coupling, we make everything much more reusable - that the services can be changed independently is but one part and the more important side is that, with such separation, both of them can be reused by future services as well, without tying them rigidly to this one integration alone.

# -*- coding: utf-8 -*-

# stdlib
from dataclasses import dataclass

# Zato
from zato.common.typing_ import cast_, dictnone
from zato.server.service import Model, Service

# ###########################################################################

if 0:
    from zato.server.connection.jira_ import JiraClient

# ###########################################################################

@dataclass(init=False)
class GetTicketDetailsRequest(Model):
    key: str

@dataclass(init=False)
class GetTicketDetailsResponse(Model):
    assigned_to: str = ''
    progress_info: dictnone = None

# ###########################################################################

class GetTicketDetails(Service):

    class SimpleIO:
        input  = GetTicketDetailsRequest
        output = GetTicketDetailsResponse

    def handle(self):

        # This is our input data
        input = self.request.input # type: GetTicketDetailsRequest

        # .. create a reference to our connection definition ..
        jira = self.cloud.jira['My Jira Connection']

        # .. obtain a client to Jira ..
        with jira.conn.client() as client: # type: JiraClient

            # Cast to enable code completion
            client = cast_('JiraClient', client)

            # Get details of a ticket (issue) from Jira
            ticket = client.get_issue(input.key)

        # Observe that ticket may be None (e.g. invalid key), hence this 'if' guard ..
        if ticket:

            # .. build a shortcut reference to all the fields in the ticket ..
            fields = ticket['fields']

            # .. build our response object ..
            response = GetTicketDetailsResponse()
            response.assigned_to = fields['assignee']['emailAddress']
            response.progress_info = fields['progress']

            # .. and return the response to our caller.
            self.response.payload = response

# ###########################################################################

Creating a REST channel and testing it

The last remaining part is a REST channel to invoke our service through. We will provide the ticket ID (key) on input and the service will reply with what was found in Jira for that ticket.

We are now ready for the final step - we invoke the channel, which invokes the service which communicates with Jira, transforming the response from Jira to the output that we need:

$ curl localhost:17010/jira1 -d '{"key":"ABC-123"}'
{
    "assigned_to":"zato@example.com",
    "progress_info": {
        "progress": 10,
        "total": 30
    }
}
$

And this is everything for today - just remember that this is just one way of integrating with Jira. The other one, using WebHooks, is something that I will go into in one of the future articles.

Next steps

• Start the tutorial to learn how to integrate APIs and build systems. After completing it, you will have a multi-protocol service representing a sample scenario often seen in banking systems with several applications cooperating to provide a single and consistent API to its callers.

• Visit the support page if you need assistance.

• Para aprender más sobre las integraciones de Zato y API en español, haga clic aquí.

• Pour en savoir plus sur les intégrations API avec Zato en français, cliquez ici.

I finally came up with a way I like to create PyCairo drawings in a Jupyter notebook.

A few years ago I wrote here about how to draw Cairo SVG in a Jupyter notebook. That worked, but wasn’t as convenient as I wanted. Now I have a module that manages the PyCairo contexts for me. It automatically handles the displaying of SVG and PNG directly in the notebook, or lets me write them to a file.

The module is drawing.py.

The code looks like this (with a sample drawing copied from the PyCairo docs):

from drawing import cairo_context



def demo():

    with cairo_context(200, 200, format="svg") as context:

        x, y, x1, y1 = 0.1, 0.5, 0.4, 0.9

        x2, y2, x3, y3 = 0.6, 0.1, 0.9, 0.5

        context.scale(200, 200)

        context.set_line_width(0.04)

        context.move_to(x, y)

        context.curve_to(x1, y1, x2, y2, x3, y3)

        context.stroke()

        context.set_source_rgba(1, 0.2, 0.2, 0.6)

        context.set_line_width(0.02)

        context.move_to(x, y)

        context.line_to(x1, y1)

        context.move_to(x2, y2)

        context.line_to(x3, y3)

        context.stroke()

    return context



demo()

Using demo() in a notebook cell will draw the SVG. Nice.

The key to making this work is Jupyter’s special methods _repr_svg_, _repr_png_, and a little _repr_html_ thrown in also.

The code is at drawing.py. I created it so that I could play around with Truchet tiles:

I'm no good at drawing. I have Affinity Designer and I like it well enough, but it requires more expertise than I have, really. Usually when I want to draw things, I prefer to retreat back to code.

Xcode playgrounds are pretty OK for writing your graphics code. Select your drawing technology of choice to create an image, create a view that displays it, make it the live view with PlaygroundPage.current.setLiveView and you're done. Well, almost. How do you get the image out of there?

Say you're creating icons for an iOS project. You want a bunch of variously sized versions of the same icon (I'm assuming here you aren't finessing the different versions too much, or otherwise you wouldn't be reading a tutorial on how to generate images in code), and you want to get them into an asset catalog in Xcode. Xcode's asset catalog editor can accept dragged files, so that seems like a something we could try enable.

SwiftUI makes it really easy.

Start with a function that draws the icon into a CGImage. This one just draws a purplish rectangle. It won't win any ADAs, but it'll serve for this tutorial:

func makeImage(size: CGSize) -> CGImage {
    let ctx = CGContext(
        data: nil,
        width: Int(size.width),
        height: Int(size.height),
        bitsPerComponent: 8,
        bytesPerRow: 0,
        space: CGColorSpaceCreateDeviceRGB(),
        bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
    )!
    let rect = CGRect(origin: .zero, size: size)
    ctx.setFillColor(red: 0.9, green: 0.4, blue: 0.6, alpha: 1.0)
    ctx.fill(rect)
    let image = ctx.makeImage()!
    return image
}

Next define a bunch of values for the icon sizes that Xcode likes. As of Xcode 13 and iOS 15, something like this is a good representation of what you need:

enum IconSize: CGFloat {
    case phoneNotification = 20.0
    case phoneSettings = 29.0
    case phoneSpotlight = 40.0
    case phoneApp = 60.0
    case padApp = 76.0
    case padProApp = 83.5
}

extension IconSize: CustomStringConvertible {
    var description: String {
        switch self {
        case .phoneNotification: return "iPhone/iPad Notification (\(self.rawValue))"
        case .phoneSettings: return "iPhone/iPad Settings (\(self.rawValue))"
        case .phoneSpotlight: return "iPhone/iPad Spotlight (\(self.rawValue))"
        case .phoneApp: return "iPhone App (\(self.rawValue))"
        case .padApp: return "iPad App (\(self.rawValue))"
        case .padProApp: return "iPad Pro App (\(self.rawValue))"
        }
    }
}

Then define a struct that holds one extra bit of information: the scale we're working at.

struct IconVariant {
    let size: IconSize
    let scale: CGFloat

    var scaledSize: CGSize {
        let scaled = self.scale * self.size.rawValue
        return CGSize(width: scaled, height: scaled)
    }
}

extension IconVariant: CustomStringConvertible {
    var description: String { "\(self.size) @ \(self.scale)x" }
}

extension IconVariant: Identifiable {
    var id: String { self.description }
}

The descriptions are useful for you, the human; the Identifiable conformance will be helpful when you set up a SwiftUI view showing the variants.

Next define all the variants you want:

let icons: [IconVariant] = [
    IconVariant(size: .phoneNotification, scale: 2),
    IconVariant(size: .phoneNotification, scale: 3),
    IconVariant(size: .phoneSettings, scale: 2),
    IconVariant(size: .phoneSettings, scale: 3),
    IconVariant(size: .phoneSpotlight, scale: 2),
    IconVariant(size: .phoneSpotlight, scale: 3),
    IconVariant(size: .phoneApp, scale: 2),
    IconVariant(size: .phoneApp, scale: 3),
    IconVariant(size: .phoneNotification, scale: 1),
    IconVariant(size: .phoneSettings, scale: 1),
    IconVariant(size: .phoneSpotlight, scale: 1),
    IconVariant(size: .padApp, scale: 1),
    IconVariant(size: .padApp, scale: 2),
    IconVariant(size: .padProApp, scale: 2),
]

Then let's start work on getting those variants on screen. We'll use a simple SwiftUI view with stacks for it; it won't be pretty, but it'll do what's needed.

struct IconView: View {
    var body: some View {
        VStack {
            ForEach(icons) { icon in
                HStack {
                    let cgImage = makeImage(size: icon.scaledSize)
                    Text(String(describing: icon))
                    Image(cgImage, scale: 1.0, label: Text(String(describing: icon)))
                }
            }
        }
    }
}

PlaygroundPage.current.setLiveView(IconView())

As promised, functionality over form:

Now we need just the glue to enable dragging. Add a CGImage extension that makes it easier to export the image as PNG data:

extension CGImage {
    var png: Data? {
        guard let mutableData = CFDataCreateMutable(nil, 0),
              let destination = CGImageDestinationCreateWithData(mutableData, "public.png" as CFString, 1, nil)
        else { return nil }
        CGImageDestinationAddImage(destination, self, nil)
        guard CGImageDestinationFinalize(destination) else { return nil }
        return mutableData as Data
    }
}

To make the images in the view draggable, you'll need to use the onDrag view modifier. It requires a function that returns a NSItemProvider. The nicest way to create one is probably with a custom class that conforms to NSItemProviderWriting. Something like this:

final class IconProvider: NSObject, NSItemProviderWriting {
    struct UnrecognizedTypeIdentifierError: Error {
        let identifier: String
    }

    let image: CGImage

    init(image: CGImage) {
        self.image = image
    }

    func loadData(
        withTypeIdentifier typeIdentifier: String,
        forItemProviderCompletionHandler completionHandler: @escaping (Data?, Error?) -> Void
    ) -> Progress? {
        guard typeIdentifier == "public.png" else {
            completionHandler(nil, UnrecognizedTypeIdentifierError(identifier: typeIdentifier))
            return nil
        }
        completionHandler(self.image.png, nil)
        // Progress: all done in one step.
        let progress = Progress(parent: nil)
        progress.totalUnitCount = 1
        progress.completedUnitCount = 1
        return progress
    }

    static var writableTypeIdentifiersForItemProvider: [String] {
        ["public.png"]
    }
}

And then the last thing needed is the onDrag handler. Add it to the Image line in the IconView you created earlier.

Image(cgImage, scale: 1.0, label: Text(String(describing: icon)))
    .onDrag {
        NSItemProvider(object: IconProvider(image: cgImage))
    }

Refresh the playground preview and the images are waiting for you to drag them into the asset catalog.

I’m happy to announce Kustosz, a new feed reader that aims to help you focus on worthwhile content.

These days, many open source RSS readers still try to fill the void left out by Google Reader - their main goal is to provide familiar visuals and user experience. Meanwhile, proprietary feed readers incorporate machine learning techniques to guide you through the vast ocean of content and try to “relieve” you from the burden of “reading everything”.

I find both of these approaches problematic. Google Reader has been discontinued a decade ago. Everyone who wanted “a Google Reader alternative” has settled on something else or moved on a long time ago. There’s no reason for a new project to try to solve this exact problem.

While it’s tempting to save time and mental capacity by allowing computers to decide what content you should focus on, this is also a fast lane to filter bubbles. Today, we are intimately familiar with psychological, social, and political problems created by employing this approach at scale. It’s more important than ever to let people decide what they want to read.

That’s why Kustosz comes from a different angle. Its goal is to make it easy and convenient to read content that you find worthwhile.

Kustosz provides easy to use, straightforward and distraction-less interface, where your content takes a central place. It works straight in your browser, so you don’t have to install additional software on your computer. It fits your device, no matter if you use a phone, tablet, or desktop with an external monitor.

We are all busy, and sometimes we can’t read the entire article in one go. That’s why Kustosz tracks how much you have read and lets you pick up right where you left at any time, on any device.

To enable you to make the most use of Kustosz features, it automatically downloads full article content from the source website. It doesn’t matter if the feed author publishes only article lead, you don’t have to leave Kustosz unless you choose to.

Kustosz is not discouraged when the article you want to read is not in the site’s RSS feed. You can add any web page manually.

While Kustosz doesn’t make any decisions for you, it’s here to automate menial tasks. It has a built-in duplicate detector that can automatically hide articles you have already seen. It provides a flexible and powerful filter system that you can use to automatically hide articles you are not interested in.

And the best part is, your data is yours. Kustosz is open source and hosted on your server. This ensures that you are in control of Kustosz, its data and what it does.

From the technical point of view, Kustosz utilizes familiar modern client-server architecture. Frontend is Vue.js (v3) web application that relies heavily on features that became widely supported in recent years, like CSS grid or JavaScript Intersection Observer API.

Backend is Django web application that serves REST-like API with help of Django REST framework. Most of the work is done in background tasks managed by Celery. All the hard work of accessing and processing RSS / Atom feed files is done by the excellent reader library. I want to stress how immensely grateful I am to Adrian for creating and maintaining this exemplary piece of code.

I’ve been using Kustosz as my primary feed reader for about a month now, and I consider it pretty stable and fit for purpose. But it’s software, so of course it has bugs - especially in contexts distinctly different from mine. If you encounter them, feel free to create an issue or submit PR at GitHub.

As is true for most of the software, I don’t think Kustosz will ever be truly finished. Right now it’s primarily concerned with text content available on public websites, but my big dream is to support various content sources - things like email newsletters and social media sites immediately spring to mind. On the other hand, I don’t think I want to re-implement RSS Bridge just for a sake of it.

Another dream of mine is to provide an integrated notepad. Reading is great, but truly worthwhile articles are thought-provoking and invitation to the conversation. Active reading demands you write down what you understood. It would be great if you could do that from the convenience of a single application.

There’s also a little more mundane work to do - things like user interface translation framework, WebSub protocol support, and improving documentation.

Nonetheless, if Kustosz sounds like a tool you could use, please head on to Kustosz website or documentation page, where you will find system requirements and installation instructions. There’s also a container image you may use to quickly spin up an instance for testing.

Looking to create an executable from Python script? Let me show you the full steps to achieve it on Windows.

Steps to create a Windows executable from a Python script using Nuitka

Step 1: Add Python to Windows Path

The simple way to add Python to the PATH do this is to check the box during installation of CPython. You just download python and install or modify Python by checking the box in the installer:

This box is not enabled by default. You can also manually add the Python installation path to PATH environment variable.

Step 2: Open a Windows Prompt

This can be cmd.exe or Windows Terminal, or from an IDE like Visual Code or PyCharm. And then type python to verify the correct installation, and exit to leave the Python prompt again.

Step 3: Install the Nuitka Python Compiler package

Now install Nuitka with the following command.

python -m pip install nuitka

Step 4: Run your Program

Now run your program from the terminal. Convince yourself that everything is working.

python fancy-program.py

Step 5: Create the Executable using Nuitka

python -m nuitka --onefile fancy-program.py

In case of a terminal program, add one of many options that Nuitka has to adapt for platform specifics, e.g. program icon, and so on.

python -m nuitka --onefile --windows-disable-console fancy-program.py

This will create fancy-program.exe.

Step 6: Run the Executable

Your executable should appear right near fancy-program.py and opening the explorer or running fancy-program.exe from the Terminal should be good.

fancy-program.exe

Lists are one of the most frequently used data structures in python. In this article, we will discuss how we can convert a list of lists to a CSV file in python.

List of Lists to CSV in Python Using csv.writer() 

The csv module provides us with different methods to perform various operations on a CSV file. To convert a list of lists to csv in python, we can use the csv.writer() method along with the csv.writerow() method. For this, we will use the following steps.

• First, we will open a csv file in write mode using the open() function. The open() function takes the file name as the first input argument and the literal “w” as the second input argument to show that the file will be opened in the write mode. It returns a file object that contains the empty csv file created by the open() function.
• After opening the file, we will create a csv.writer object using the csv.writer() method. The csv.writer() method takes the file object as an input argument and returns a writer object. Once the writer object is created, we can add data from the list of lists to the csv file using the csv.writerow() method.
• The csv.writerow() method, when invoked on a writer object, takes a list of values and adds it to the csv file referred by the writer object.
• First, we will add the header for the CSV file. For this, we will pass a list of column names to the writerow() method
• After adding the header, we will use a for loop with the writerow() method to add each list to the csv file. Here, we will pass each list one by one to the writerow() method. The writerow() method adds the list to the csv file. 

After execution of the for loop, the data from the list will be added to the CSV file. To save the data, you should close the file using the close() method. Otherwise, no changes will be saved to the csv file.

The source code to convert a list of lists to a csv file using the csv.writer() method is as follows.

import csv

listOfLists = [["Aditya", 1, "Python"], ["Sam", 2, 'Java'], ['Chris', 3, 'C++'], ['Joel', 4, 'TypeScript']]
print("THe list of lists is:")
print(listOfLists)
myFile = open('demo_file.csv', 'w')
writer = csv.writer(myFile)
writer.writerow(['Name', 'Roll', 'Language'])
for data_list in listOfLists:
    writer.writerow(data_list)
myFile.close()
myFile = open('demo_file.csv', 'r')
print("The content of the csv file is:")
print(myFile.read())
myFile.close()

Output:

THe list of lists is:
[['Aditya', 1, 'Python'], ['Sam', 2, 'Java'], ['Chris', 3, 'C++'], ['Joel', 4, 'TypeScript']]
The content of the csv file is:
Name,Roll,Language
Aditya,1,Python
Sam,2,Java
Chris,3,C++
Joel,4,TypeScript

Conclusion

In this article, we have discussed an approach to convert a list of lists to csv file in python. In these approaches,  each list will be added to the csv file irrespective of whether it has the same number of elements as compared to the columns in the csv or not. Thus it is advised to make sure that each element should have the same number of element. Also, You should make sure that the order of element present in the lists should be same. Otherwise, the data appended to the csv file will become inconsistent and will lead to errors. 

To know more about lists in python, you can read this article on list comprehension in python. You might also like this article on dictionary comprehension in python.

The post Convert List of Lists to CSV File in Python appeared first on PythonForBeginners.com.

When you are teaching someone web development skills, when is the right time to start teaching code quality and testing practices?

Karl Stolley believes it's never too early. Let's hear how he incorporates code quality in his courses.

Our discussion includes:

• starting people off with good dev practices and tools
• linting
• html and css validation
• visual regression testing
• using local dev servers, including https
• incorporating testing with git hooks
• testing to aid in css optimization and refactoring
• Backstop
• Nightwatch
• BrowserStack
• the tree legged stool of learning and progressing as a developer: testing, version control, and documentation

Karl is also writing a book on WebRTC, so we jump into that a bit too.

Special Guest: Karl Stolley.

Sponsored By:

• Patreon Supporters: Help support the show with as little as $1 per month and be the first to know when new episodes come out.
• Python Testing with pytest, 2nd edition: The fastest way to learn pytest and practical testing practices.

Links:

• Backstop
• Nightwatch
• BrowserStack
• Programming WebRTC: Build Real-Time Streaming Applications for the Web by Karl Stolley