Falcon2001 posted:

So I have a bit of a best practices question. In the event that you have a function that mutates a data structure like a list/etc, is it best practice to return the mutated version, or to just make it clear in the docstring that the function mutates the object? For the sake of argument, let's assume that this isn't a library or other externally facing function and is pretty tightly bound business logic specific to a situation, where you're separating code out into functions to improve readability/etc.

code:

big_dict = retrieve_data()
remove_butts(big_dict)

vs

code:

big_dict = retrieve_data()
big_dict = remove_butts(big_dict)

Protocol7 posted:

I think that's kind of up to your preference. Though if you are not returning anything then you should be very clear that the function does not return anything and thus mutates an argument as a side effect. It shouldn't do both; either return a new object or mutate the existing one.

Falcon2001 posted:

So I have a bit of a best practices question. In the event that you have a function that mutates a data structure like a list/etc, is it best practice to return the mutated version, or to just make it clear in the docstring that the function mutates the object? For the sake of argument, let's assume that this isn't a library or other externally facing function and is pretty tightly bound business logic specific to a situation, where you're separating code out into functions to improve readability/etc.

code:

big_dict = retrieve_data()
remove_butts(big_dict)

vs

code:

big_dict = retrieve_data()
big_dict = remove_butts(big_dict)

Falcon2001 posted:

Thanks for the feedback! I think the biggest takeaway is that it should be clear, and I properly type hint all my functions/etc, so it's clear that this doesn't return anything (-> None), which means I think I'm going in the right direction.

I also agree with the nicest option being the 'make it a class and then have a method that does the thing to itself'. This is a four year old codebase that I just came into, so there's a few different places we're just passing dictionaries around instead of using dataclasses/etc. Some of those I'll be trying to clean up as I go along and generally docstring or otherwise fix up some of the older bits of this program.

QuarkJets posted:

I like to do both, personally: mutating the input and also returning it. So long as the behavior is consistent I think that's what really matters (if you have a bunch of list mutators, they should all have the same behavior)

quote:

Some operations (for example y.append(10) and y.sort()) mutate the object, whereas superficially similar operations (for example y = y + [10] and sorted(y)) create a new object. In general in Python (and in all cases in the standard library) a method that mutates an object will return None to help avoid getting the two types of operations confused. So if you mistakenly write y.sort() thinking it will give you a sorted copy of y, you’ll instead end up with None, which will likely cause your program to generate an easily diagnosed error.

QuarkJets posted:

There's a lot of extraneous stuff going on here and I don't really understand what you want to do, sorry. Here's a simple example that flips a QLabel between two images, is that kind of what you're looking for?

Protocol7 posted:

I was curious so I looked it up. The docs say that they try to avoid doing both in the standard library.

https://docs.python.org/3/faq/programming.html#why-did-changing-list-y-also-change-list-x

Not really much of an official style guideline on it that I could find though. And of course it's a bit different when calling an instance method like y.sort() IMO.

punk rebel ecks posted:

My goal is to have the yellow light keep blinking until the "extract" function is finished.

ExcessBLarg! posted:

If the extract function takes "a long time" to run, and you're running it on the same thread as your Qt event loop, then those QTimers won't fire until the function is done and the event loop runs again.

See Use PyQt's QThread to Prevent Freezing GUIs.

punk rebel ecks posted:

While this does seem to be what I'm looking for, it's a bit too advanced for me.

Not QThread as a concept, but the fact that I'm doing so many things in the button click at once it will be difficult to know how to separate it all into various functions for the worker threads.

I may just edit the yellow light out and use the loading idea for a future project.

punk rebel ecks posted:

Protocol7 posted:

Thought someone would get a kick out of this terrible fstring I wrote today.



Remind me how I get paid to write Python again?

Protocol7 posted:

Thought someone would get a kick out of this terrible fstring I wrote today.



Remind me how I get paid to write Python again?

Armitag3 posted:

Apparently this works

Python code:

guid = "1234-123123-12123-1234"
print(f"{{{guid}}}")
# > {1234-123123-12123-1234}

lol

QuarkJets posted:

It's still very difficult to diagnose what's going on here. What kind of object is Data? Why is self being passed to it? What does Data.run_api do? What invokes extract()? Is extract() part of a QDialog class or something else? There could be a lot of reasons that are causing you to see what you're seeing, basically. Places like stackoverflow have a rule that sums up as "post complete examples" for this reason, it's probably impossible to say exactly what's going on here using only what's shown.

punk rebel ecks posted:

So the last issue I'm having with my project is that I'm trying to have the bottom label scrollable .

QuarkJets posted:

I'm not aware of one, it's too easy to just slice as sequence[i:i+length]

QuarkJets posted:

This looks like a geometry issue. See here: https://doc.qt.io/qt-5/application-windows.html#window-geometry and the description of geometry here: https://doc.qt.io/qt-5/qwidget.html#geometry-prop, which is what's being manipulated when you use setGeometry(int, int, int, int)

Basically, your other widgets are all given a parent widget:

Python code:

self.summary_screen = QLabel(placeholder_text, self)

This creates a QLabel, assigns it some text, and then assigns a parent widget (in this case: self, which is an instance of your MainWindow class, which inherits from QWidget). But the QScrollArea you create has no parent assigned. Try giving it the same parent as your other objects, like this:

Python code:

self.scroll_area = QScrollArea(self)

That's probably enough.

QuarkJets posted:

Returning to your earlier question, it seems like you should shove nearly all of the code in your extract() method into a new method that gets handled by a QThread or QThreadPool. But also, you're using a lot of repeated calls to a website to fetch the same data over and over:

Python code:

    def run_api(self,directory, subdirectory):
        self.directory = directory
        self.subdirectory = subdirectory
        contact = {'User-Agent': '("Accept: application/json", "Cache-Control: max-age=360",)'}
        response = requests.get (f'https://pokeapi.co/api/v2/{self.directory}/{self.subdirectory}', headers = contact)
        self.data = response.json()

This is nearly always being invoked in the same way: Data.run_api(self,"pokemon", self.pokemon) (by the way, this should be rewritten as self.run_api("pokemon", self.pokemon)). It'd be better to cache this information somewhere and only request it again if self.pokemon changes, that'd probably make your application more responsive.

punk rebel ecks posted:

What do you mean by "cache this information somewhere"?

D34THROW posted:

Retain it in local memory somewhere, rather than fetching it each and every time. Your browser doesn't fetch the little bookmark star, or the images on the quote/report/reply buttons each time you need them. Rather, it caches them locally for faster lookup.

D34THROW posted:

Phoneposting so no code, but if self.data is overwritten for each new loaded Pokemon, what I would do is store the self.data json (I'm assuming, or dict) in a dict cached_data, keyed by, say, the Pokemon number. Then I would add a clause to whatever function pulls the data to check first if that pokemons data is in cached_data, then pull from the API if it isn't.

punk rebel ecks posted:

I’m not sure how to make a dict for cached-data.

nullfunction posted:

Python code:

# pokemon.py
import requests

# The dict where we'll store the results locally from your API calls
local_pokedex = {}

class PokemonApi():
    @staticmethod
    def get_pokemon(name: str) -> dict:
        # Probably not a bad idea to add some error handling around this! APIs fail sometimes!
        contact = {'User-Agent': '("Accept: application/json", "Cache-Control: max-age=360",)'}
        response = requests.get(f'https://pokeapi.co/api/v2/pokemon/{name}', headers=contact)
        return response.json()

class Pokemon():
    def __init__(self, data: dict):
        self.name = data['name']
        self.height = data['height']
        self.height_cm = self.height * 10
        self.height_ft = self.height_cm * 0.0328084
        # Other interesting attributes could be processed here,  or if you're not sure what 
        # you'll use, you might store the entire JSON
        # As the final step of initializing, update the cache
        local_pokedex[self.name] = self
    
    @classmethod
    def from_api(cls, name: str):
        return cls(data=PokemonApi.get_pokemon(name))
    
    @classmethod
    def from_cache(cls, name: str):
        if name not in local_pokedex.keys():
            # We don't have this pokemon in our local cache, so we have to go to the API
            return cls.from_api(name)
        # If we're here, we know we have a cached version of the pokemon and don't need to call the API
        return local_pokedex[name]

D34THROW posted:

Pokemon.from_cache returns a new instance of Pokemon (i.e. a constructor) if the Pokemon is not in the API, or the copy of the locally cached data. In other words, from_cache is a Pokemon factory?

I had a pretty decent grasp of factory patterns and interfaces in VBA but for some reason, in Python they break my brain.