Are you doing data science? Statistics? No?

Then for god's sake don't use pandas, you just look dumb af when you pull several MB of a package just to load csv. If you find yourself doing that, just stop programming and look for another job

Thanks for attention

Hi everyone,

I'm pleasantly surprised and very thankful for the traction Plemmy has received in a few short weeks since its initial release!

The primary goal of Plemmy is simple: offer access to the LemmyHttp API in Python, allowing users to interact with any Lemmy instance using Python.

Plemmy's LemmyHttp object does just this, returning Python request.Response objects resulting from Lemmy API calls. All LemmyHttp functions have been implemented!

With release 0.3.0, Plemmy now offers a way to parse request.Response objects, extracting all information and placing them in easy-to-use Python objects. The design of these functions/objects closely mirrors the objects and data types defined in the lemmy-js-client.

These additions should make interacting with Lemmy in Python easier than ever. Check out Plemmy's repository for example usage (more documentation to come!).

Thanks for the continued support,

Travis

Featuring:

• Identifying bundled libraries on Python distributions to help scanning for vulnerabilities.
• Trusted Publisher adoption metrics.
• GitHub push protection for PyPI API tokens.

Lots of great stuff!

I am writing an object-oriented app to help our developers manage some cloud systems. I'd like to make the configuration information available to all the classes, but I'm not sure of a good way to do that. Everything I can think of seems to fall under the category of "global variables" which as far as I know is a Very Bad Thing.

I already have a logging Mixin class that enables logging for every class that inherits it, and I was wondering if that's the right way to approach the configuration data:

class LoggingMixin:
    @classmethod
    @property
    def log(cls):
        return logging.getLogger(cls.__name__)

class TestClassA(LoggingMixin):
    def testmethod1(self):
        self.log.debug("debug message from test class A")

if __name__ == "__main__":
    logging.basicConfig(
        format="{created:<f} {levelname:>5s} {name}.{funcName:>8s} |{message}|",
        level=logging.DEBUG,
        style="{",
    )

    a = TestClassA()
    a.testmethod1()

Outputs (in case you are curious)

1688494741.449282 DEBUG TestClassA.testmethod1 |debug message from test class A|

What's a good way of making data from a class available to all classes/objects? It wouldn't be static, it'd be combined from a JSON file and any command line parameters.

If I copied the example above but changed it to a ConfigMixin, would that work? With the logging example, each class creates its own logger object when it first calls self.log.debug, so that might not work because each object needs to get the same config data.

Is there a pattern or other design that could help? How do you make configuration data available to your whole app? Do you have a config object that can get/set values and saves to disk, etc?

Thank you for reading, my apologies for poorly worded questions.

An exploration of partial() and partialmethod() in functools

VS Code is dropping Python 3.7 support in September 2023 and with the following Python releases they are planning to drop support of a Python version in the first extension release of the year following after EOL.

Once you've installed it, pytest will produce nice colourised diffs for any assert == :

😍

Via https://mastodon.social/@hynek/110479665200902390

Last month, I developed a script because lemmy.ml had become too slow. Unfortunately, I have the same problem again, but this time there are too many instances to evaluate, causing the script to take an excessively long time to complete. I'm seeking advice on how to enhance the script to simultaneously ping multiple instances. Are there any alternative scripts available that might provide a more efficient solution?

git clone https://github.com/LemmyNet/lemmy-stats-crawler
cd lemmy-stats-crawler
cargo run -- --json > stats.json

#!/usr/bin/env python3
import json
import time
import requests
import requests.exceptions

from typing import List, Dict

TIME_BETWEEN_REQUESTS = 5  # 10 * 60 = 10 minutes
TIME_TOTAL = 60  # 8 * 60 * 60 = 8 hours


def get_latency(domain):
    try:
        start = time.time()
        if not domain.startswith(("http://", "https://")):
            domain = "https://" + domain
        requests.get(domain, timeout=3)
        end = time.time()
        return end - start
    except requests.exceptions.Timeout:
        return float("inf")


def measure_latencies(domains, duration):
    latencies = {}
    start_time = time.time()
    end_time = start_time + duration
    while time.time() < end_time:
        latencies = measure_latencies_for_domains(domains, latencies)
        time.sleep(TIME_BETWEEN_REQUESTS)
    return latencies


def measure_latencies_for_domains(domains, latencies):
    for domain in domains:
        latency = get_latency(domain)
        latencies = add_latency_to_domain(domain, latency, latencies)
    return latencies


def add_latency_to_domain(domain, latency, latencies):
    if domain not in latencies:
        latencies[domain] = []
    latencies[domain].append(latency)
    return latencies


def average_latencies(latencies):
    averages = []
    for domain, latency_list in latencies.items():
        avg_latency = sum(latency_list) / len(latency_list)
        averages.append((domain, avg_latency))
    return averages


def sort_latencies(averages):
    return sorted(averages, key=lambda x: x[1])


def get_latency_report(domains, duration):
    latencies = measure_latencies(domains, duration)
    averages = average_latencies(latencies)
    return sort_latencies(averages)


def get_instances(data: Dict) -> List[Dict]:
    instances = []
    for instance_details in data["instance_details"]:
        instances.append(instance_details)
    return instances


def get_domains(instances: List[Dict]) -> List[str]:
    return [instance["domain"] for instance in instances]


def load_json_data(filepath: str) -> Dict:
    with open(filepath) as json_data:
        return json.load(json_data)


def main():
    data = load_json_data('stats.json')
    instances = get_instances(data)
    domains = get_domains(instances)
    report = get_latency_report(domains, TIME_TOTAL)
    for domain, avg_latency in report:
        print(f"{domain}: {avg_latency:.2f} seconds")


if __name__ == "__main__":
    main()

After learning about TYPE_CHECKING i made it a habit to put all imports that were only needed for type checking into an if TYPE_CHECKING: guard. But now I am wondering if that is actually intended to be used like that. Checking whether an import is only needed at type checking time can get quite tedious and sometimes you run into situations were you introduced some code that made the import a requirement at runtime.

How do you use TYPE_CHECKING? Whenever it is possible or only when using it actually solves a circular import?

This usage test works already. Whadda ya guys think?

The Pure #Python #webapp survey is here - https://metaperl.github.io/pure-python-web-development/intro.html

Recent Updates

• 2023-07-05 Added todomvc in shiny.
• 2023-07-05 Moved Htag to the top of Class B in anticipation of a PR for it's TODOMVC.
• 2023-07-03 Added suggestions on "Helping a user use plotly graphs and interactivity with Panel"
• 2023-06-30 Added Panel example of A tree widget from jsTree
• 2023-06-30 Linked to the impressive Holoviz tool stack that Panel is part of.
• 2023-06-30 Reformatted Panel section.
• 2023-06-30 Added Panel example of using MapLibre with ReactiveHTML
• 2023-06-24 Merge pull request #1 from rodja/main
• 2023-06-19 Added TODOMVC in Flet
• 2023-06-13 Added the Streamlit Login/ Sign Up Library
• 2023-06-11 Added Talk To Your CSV: How To Visualize Your Data With Langchain And Streamlit
• 2023-06-11 Promoted Abstracloud from Class C to Class B.
• 2023-06-11 Added reasons to prefer shiny over streamlit
• 2023-06-11 Added Streamlit Reddit Channel
• 2023-06-11 Added Streamlit running entirely in WebAssembly (using Pyodide)
• 2023-06-11 Added Streamlit audio recorder
• 2023-06-10 aDDED How to Embed a Python Streamlit App in WordPress with Replit
• 2023-06-10 Added the streamlit app for archaix.
• 2023-06-10 Added [Streamlit meets Headless BI]O(https://medium.com/gooddata-developers/streamlit-meets-headless-bi-cb6196b69671) - https://www.reddit.com/r/Python/comments/13kx175/streamlit_meets_analytics_headless_bi/
• 2023-06-10 Added Streamlit app for doing tarot readings with OpenAI - https://github.com/msull/emilytarot
• 2023-06-10 Added ReactPy: Will it Dethrone JavaScript as the Top Choice? - https://www.reddit.com/r/Python/comments/145u6y9/reactpy_will_it_dethrone_javascript_as_the_top/
• 2023-06-10 Added Getting started with Reactpy - https://www.kdnuggets.com/2023/06/getting-started-reactpy.html - https://www.reddit.com/r/Python/comments/145bf6d/getting_started_with_reactpy/
• 2023-06-08 Added Streamlit-Powered Python Web Apps for Team Research to class-b.md.
• 2023-06-08 Added PyScript Limitations for building data web apps to class-c.md

pytheus is a modern python library for collecting prometheus metrics built with multiprocessing in mind.

Via https://mastodon.social/users/hynek/statuses/110661478399781347

Hello fellow lemmians (I hope that is correct), I want to learn a programming language in my free time, like a hobby and not necessarly for work. I think a general purpose language like python would be a good choice. I'm the type who prefer paperback books to minimize distraction and I would like your recommendation for a book, Im thinking about "Python crash course 3d edition" but feel free to suggest something else

Simple Python [executable] version management, that is.

Via https://mastodon.social/@hynek/110655873748943682

It has a single purpose: to help you write correct retry logic effortlessly.

If you’ve looked at it before: it now has proper docs, support for async, and retries of arbitrary code blocks.

Via https://framapiaf.org/@bitecode/110656440273902608

The Github profile: https://github.com/davep/

Hi everyone!
I am learning about using selenium and/or playwright and I'm struggling with something that I am struggling to find a good solution to.
Prevent webRTC leaking my real IP when using proxies with either Selenium or Playwright.

There's plenty of janky workarounds I've seen but they all just seem like they have issues and/or cause issues. What would be the right way to prevent WebRTC IP leaking?

After seeing the work someone else did with migrating your subscriptions across accounts. I took their code and expanded upon it to fully synchronize your Lemmy instance accounts.

Feel free to give it a try. It's been useful for me to have accounts in multiple instances with the instability problems right now from the big influx of users.

Let me know what you think. Hopefully it can help a few people.