For deeper context, check out my profile for my previous post in r/it for further details. The shortened version of it is that I have a repetitive data entry process that I do for my job. It's something I do for myself because the results actively predict where I need to be to effect the best results. My company makes deliveries of a sort to over 1000 diffrent locations across my state. Knowing what our trucks are capable of delivering let's me know the operational condition of the equipment inside. As the companies service tech, I'm searching for broken systems that need repair, so I can get a very clear heads up of the problem areas long before the customers call it in. (Example: If we regularly make a delivery of 600# and the last two deliveries show its dropped down to 50#, there's obviously something wrong there) I have a website database where every delivery is recorded. I've created a Google sheets file that's set up with formulas to crunch all the numbers for me. All I have to do is copy that delivery data from the website to the sheet and it automaticly calculates the rest. The website takes 60 seconds at least to collect the delivery data on one delivery. I compare it to what I have in the sheet and add in the new information. In order to keep up with the deliveries, I usually try to do data entry on about 100 entries each day. This process takes at least an hour every day whether it's a work day, weekend, or vacation. I get to spend at least an hour every day doing data entry work. The goal I'm looking to accomplish is to move my Google sheets file over to some kind of automated program that will collect the data and crunch the numbers automaticly for me. Such a program would literally give me an hour more of free time every day. So it's definitely worth it to do. So the question is, how should I do this? Should I learn how to program and do this project myself, or does it make sense to hire someone to create the program for me, and then when I learn programming, I can take over the program. On the one hand, either way, I plan on learning programming, so I can save money and make the program myself, it's a win for me. On the other hand, having someone else do it for me means I get an experienced hand to do it correctly the first time without the guess work that comes with doing while learning. Additionally, saving that hour every day gives me that much more time I could put towards learning programming myself. If I go that route, what would be a fair charge to expect for such a project, and is there anyone who would want to take on such a project? submitted by /u/jrjocham [link] [comments]

Hello, I am an Instructor on Udemy and I wanted to publish a Python Fundamentals course in Youtube. You can access to the first lecture of the course from the following link, thank you! https://www.youtube.com/watch?v=yCASixTyMMY submitted by /u/onurbaltaci [link] [comments]

Hello, I made a complete Data Science project from scratch (Data analysis, Feature engineering and Machine Learning) and uploaded it to the youtube. I explained the codes and how they work in my video. I'm leaving the link below. Have a nice day, thanks! https://www.youtube.com/watch?v=od_mSGnf18o submitted by /u/onurbaltaci [link] [comments]

Github: https://github.com/v-ko/pamet There's a gazillion note taking apps, I know, but when I started the project - there was none with the GUI I imagined. Currently Miro is pretty close, but it's closed source and it's not possible to keep your data locally, so that's the main reason I continued developing Pamet. ​ Demo A bit of history I couple of years ago I began rewriting the app from C++/Qt to Python/Qt (PySide6). I started out with over-engineering and over-thinking it, drowning in the cross-platform-GUI swamp of technologies and so on. In the end I decided I'll use mainly Python (since I use it for work and also I love the syntax). I would try to be noobishly DRY and the reuse the actions/states with Brython in the browser and then Cordova for mobile (sounds like a great debugging experience right?). So some time passed, I stripped my gui-architecture ambitions to a state manager (Fusion) and finished the initial version of the app. In retrospect - I should've done the standard thing nowadays - make a web frontend (e.g. React) with an Electron desktop app and whatever for mobile. I'll probably transition in that direction in time. But for now - I'm happy with the results. Capabilities and philosophy ("Pamet" means memory in Bulgarian.)The main idea is to have 2D map-like pages (pan, zoom navigation) with notes, that can be made and styled fast. There's hyperlinking between different pages. There's a backup service by default (though restoring backups is manual for now). You can import images (audio, video - not yet implemented). You can have web links as notes, as well as activate scripts (open by double-click). Most of the testing is done on Linux. The Windows build is outdated ATM, so I'd recommend a PyPI install. I have yet to showcase the way I'm using the app, but I beilieve that everyone makes their own pattern in time. The 2d plane + hyperlinking GUI is the UI closest to the way I connect concepts in my mind, and organize clusters of them. Pamet is not supposed to be a do-it-all program, but rather it should serve for organizing ideas, "second-brain" is fitting buzzword right now. But it won't try to be a spreadsheet editor, image editor, specialized kanban, etc. For example right now you can import images, but editing them is done by double-clicking them to open the file, and then using whatever software you have. So the point is to keep references and possibly previews of external resources, but integrate with the existing tools, rather than reinvent the wheel. I'd appreciate feedback The project is still quite immature. I've been using it daily for quite a while now, but I realize that my habits are a niche, so I don't expect it would be applicable for everyone. I'd be thankful for any and all constructive feedback. About the interface, about the code, about what similar software you're using, etc. Still this is not exactly a release I wouldn't dub this post a release, since there's quite some more work to be done. The user documentation is quite minimal. Installation is done only from PyPI or source. It's mostly a showcase. But I've put quite a lot of work in the project, and I really wanted to put it out there and get feedback. submitted by /u/vko- [link] [comments]

Hi. What's the easiest area/field to get into if you're a beginner Python programmer? I did 17 years programming in Coldfusion and am now learning Python. I appreciate any advice. Thanks. submitted by /u/redditjorge6 [link] [comments]

Hey again, Original post with more context here. TLDR - what is it? py-template is a GitHub Template repository for Python, which provides: Opinionated linting, autoformatting, etc. (this update changes flake8 to substantially faster ruff CI/CD, test coverage, automated documentation creation pre-commit integration for easy local development similar to pipelines Automated dependency management via poetry, renovatebot This update also includes more extensive documentation describing how to adjust the template to your liking (e.g. consistent Python versioning, shell aliases for one click setup and more), click here to check our docs. We hope you are gonna find it as useful as we do (and if so, star/follow is always appreciated), thank you! submitted by /u/szymonmaszke [link] [comments]

submitted by /u/lokiju_jukilo [link] [comments]

​ FizzBuzz implementation in FCL Hello, recently made an interpreted language in python and haven't decided on its use cases or if I wanna be serious about it or not but just wanted to share. The idea is to use function for everything although the language currently doesn't even support creating function which I will add soon. There's probably thousands of languages like this but wanted to find a unique use-case for now the real problem is speed so might rewrite in C++ or rust. Also would like some feedback from pro language creators if my implementation is correct or not? for an average interpreted langauge. Link: FCL (GitHub) submitted by /u/FUS3N [link] [comments]

Filequery is an open source CLI tool I've been working on so I can easily use SQL to query CSV, Parquet and JSON files. I wrote this as a Python package which is essentially a wrapper around DuckDB. This lets you one or more queries against a file or a directory containing files and see the result in the terminal. You can also save the query results as CSV or Parquet files. Open to feedback and suggestions. https://pypi.org/project/filequery/ submitted by /u/yettiontheweb [link] [comments]

Disclaimer: It says "March '22" in the title but it should say "March '23". The new are from today, not a year ago. Hello fellow Pythoneers, it's time for me to once more talk about Starlite for a bit! Recap What's Starlite? Starlite is a flexible and highly performant ASGI framework, focused on building APIs while delivering great developer experience by offering ready-built solutions for common tasks such as ORM integration, caching, session management, key/value stores, OpenAPI-schema generation and interactive API docs, type safety and much more. You can read more about Starlite's features in our documentation! So what's new? Starlite 2.0 on the horizon It's been over two months since we announced Starlite 2.0, more as a side note than major news, so it's about time to see how things are going! Firstly, as with any proper project, there has been a slight feature creep, and the 2.0 update will be a bit more involved as initially expected. But we have it under control. We can stop at any time. I promise. Jokes aside, the announcement still holds true: Starlite 2.0 retains most of its core functionality, and from a user perspective, not a lot has to change when upgrading your app from 1.x to 2.0; If you don't want to make use of new features, the upgrade path will mostly consist of changing some import paths and slightly adjusting a few configuration values. But let's take a look at what has changed, and what is yet to come. Adieu Pydantic Starting with the release of 2.0.0alpha1, Starlite replaced most of its internal models that relied on Pydantic (mostly with data- or plain classes). In the following releases leading up to 2.0, we will remove the last dependencies on Pydantic, and you can use Starlite completely Pydantic-free. But why? The main motivations behind this were performance improvements and flexibility: Performance Pydantic is a great library, but being fast is not one of its strengths. Its performance will likely increase drastically in version 2.0, with the core validation logic written in Rust, but early tests indicate that it will likely still be slower than other libraries when it comes to (de)serialization. In many cases this might not be an issue, but having the option to switch to an alternative if desired is still a valuable option, and can have significant impact on the overall performance of an application. Flexibility Pydantic is by far not the only library of its kind, with prominent members of the same class being attrs, cattrs or even plain dataclasses for some use cases. Starlite currently only supports modelling data with Pydantic, which means this will necessarily force an integration of Pydantic into the rest of the application's layers, be it by directly using Pydantic models there, or simply the need of an additional "translation layer". By removing Starlite's reliance on Pydantic, we're opening doors to a new, more flexible type of integration, which will ultimately allow to plugin in arbitrary modelling libraries. Does this mean I won't be able to use Starlite with Pydantic anymore? No. Starlite will continue to support Pydantic modelling of any kind, and you'll be able to keep using Pydantic models everywhere you've used them before. Pydantic will be removed as a core dependency eventually, which means Starlite will be able to run without it, but there are no plans to stop supporting it. All new DTOs DTOs will become more integral in Starlite 2.0, taking care of most of the data conversion between various types of models. This feature is yet to be released, but it will allow you to seamlessly use data modelled with for example Pydantic, SQLAlchemy, msgspec or dataclasses in your route handlers, without the need for an intermediary model; The conversion will be handled by the specific DTO "backend" implementation. This new paradigm also makes it trivial to add support for any such modelling library, by simply implementing an appropriate backend. emit("We have an event bus now") Starting with the first alpha release - 2.0.0alpha1 -, Starlite includes a simple event bus that can be used to emit and receive events, supporting both synchronous and asynchronous listeners. Currently only a basic in-memory, per-process backend is included, but future versions will add support for inter-process communication by adding backends for Redis, RabbitMQ and others. This is an exciting new feature, as it allows powerful patterns such as websocket broadcasting, or can, in combination with background tasks, eliminate the need for external task queues such as celery or arq. Data stores Another exciting new feature coming in 2.0 are the all new, fully integrated data stores. They are simple key/value stores, including backends for the file system, memory, or common key/value databases like Redis. These stores are managed centrally by a registry, providing easy configuration, isolation and a hierarchical structure via namespacing, and integration with third parties such as plugins. Via the registry it's possible to easily access stores used by various built-in features such as rate-limiting or request caching, making them available throughout the entire application context. What else is new? To keep this post (relatively) brief I won't mention all the changes going into 2.0, so if you want to know everything that's changed until now, you can take a look at the detailed 2.x changelog, which includes all the currently released changes, features (and bugfixes). What's left to do There are a few more things that have to be done before Starlite 2.0 will be released. Yesterday the second alpha version (2.0.0alpha2) has been released, but it won't be the last development release before 2.0.0. A few major items on the 2.0 todo-list currently are: Finishing new DTO implementation New signature modelling backend using attrs Remove the remaining parts that rely on Pydantic Writing a migration guide for 1.x > 2.0 Writing tutorials / prose documentation for the SQLAlchemy repository and of course lots of minor issue that need taking care of. There is no set release date for 2.0, but as things are currently going, I expect one more alpha release before the first beta version comes out. At this point, no more breaking changes will be introduced, allowing the beta to be tested for a while before it can be considered stable and ready for the final release. And as always, if you want to get involved or in touch, check out Starlite on GitHub or join our Discord! submitted by /u/provinzkraut [link] [comments]

Hi there ! I'm curious what are you using to generate executable files for you Python scripts because I'm getting angry at some popular ones. I got some problems for my program with Pyinstaller as I think it didn't put the dependencies into the executable, the program wasn't working on computers without Python installed. As for cx_Freeze, it got the dependencies into it ( at least I think, as It created some extra files .dlls and other stuff ), but the executable didn't work at all because it got an error at run about input lines that I've put in the code(in main.py, not setup.py) ( the program works in Pycharm ). submitted by /u/M4l4wn [link] [comments]

I always thought of 1+N as a thing that you just keep in your head, catch on code reviews or via performance regressions. But preventing it might be a good idea too. Read more submitted by /u/hackflow [link] [comments]

submitted by /u/Asleep-Dress-3578 [link] [comments]

Hashport is a function that generates a port number using a deterministic hashing algorithm. It takes a string input as the name of the project or entity that requires a port number and returns an integer value that falls within the range of ports typically used for dynamic assignments (49152 to 65535). The function uses the SHA-256 algorithm to generate a hash of the input string. The resulting hash is then converted to an integer, and the integer is scaled to the desired range using modular arithmetic. Hashport is useful in scenarios where a fixed and deterministic port assignment is required. By hashing the project name, the same input will always generate the same output, ensuring consistency and predictability in port assignments. Python library: https://github.com/labteral/hashport submitted by /u/brunneis [link] [comments]

submitted by /u/siilkysmooth [link] [comments]

Tell /r/python what you're working on this week! You can be bragging, grousing, sharing your passion, or explaining your pain. Talk about your current project or your pet project; whatever you want to share. submitted by /u/Im__Joseph [link] [comments]

submitted by /u/thetech_learner [link] [comments]

I just found out that Streamlit defaults to sending telemetry data to Streamlit (and so sends it to Snowflake). While they say this is only metadata and not app information, I'm not totally sure I trust that. https://docs.streamlit.io/library/advanced-features/configuration#telemetry submitted by /u/IntelligentDust6249 [link] [comments]

It even has a text editor with syntax highlighting! what do you guys think? https://github.com/cmspeedrunner/Zang submitted by /u/cmnews08 [link] [comments]

Hey everyone, I figured someone could benefit from this. I mainly use a Mac or Linux. I migrated from Windows earlier last year and haven't looked back. However, in my job as a Cloud Engineer/DevOps Engineer/WhateverTheyTellMeToBeNeer I still have to maintain some Windows servers. I'm a big terminal guy. I like being able to SSH into a server when I need a few quick things and be done. Well, SSH into Windows is possible now. However, most enterprises do not support this and you are working off of older based severs that would not even support this. This means you have to RDP into the server. I HATE RDP!!!! This got me thinking, well, what about if you make a terminal to connect from Mac/Linux to Windows using the WinRM library in Python? I started thinking about it more, what if I used something that does it already and does it well? Ansible!!! What if you used Ansible as the backend, and created a mock terminal you could send commands through??? Winner!!! So pywinterminal is exactly that. It is a fancy forever loop that allows you to send commands to a Windows server through a mock terminal. It maintains history and directory state. So if you send a command "cd c:\windows\temp", then the next command you sent "dir", it would output the the dir of "C:\windows\temp". This is still a work in progress, but it has been an absolute life saver for me. There are limitations. if you set a variable, value is not not maintained. This is something I am looking into. HOWEVER, you can send piped commands and multiple commands like "get-service | where name -like *win*" or "mkdir c:\temp; cd c:\temp; dir". It uses Ansible in the backend to send all this stuff back and forth. I may be able integrate this a bit more and have a custom playbook to keep a sort of "variable state". Until then it has a basic functionality. It an open source project, and it is in an early alpha stage so their will be bugs. I have not extensively tested everything, but for general use it works. Code is a bit rough and by no means final. I do this in my spare time as I have time, which isn't much. Please enjoy! I hope it makes someone's life easier! https://github.com/mcscwizzy/pywinterminal submitted by /u/mcscwizzyy [link] [comments]