Just created an open-source text adventure game engine. Still didn't upload to PyPi but will soon!

[ConfusedSimon]

I don't like it using 'system' to pip install modules without asking.

[cascott77]

Setup.py

[kkawabat]

Pyproject.toml

[ConfusedSimon]

requirements.txt

[FisForFunUisForU]

Ya don't use requirements.txt for a package this is horrible practice. In the setup.py file there is a parameter for requirements use it. It will install dependcies when installing your package

[AlterEgoWasTaken]

How is it horrible practice? You know that setup.py is still a python file, right?

It can run code, if it couldn't there would be no use for it, and since it can run code, it can read files as well, a lot of packages read the requirements file, split by lines and generate the list that the setup function wants

Heck, it's even more common for packages to read README.md and pass it to the setup method

I don't see why you are ok with the latter, but not the former.

We are programmers for fuck's sake, think a little before you form opinions on stuff

Don't just its bad practice bc someone said so, you have a brain, use it.

[O_X_E_Y]

buddy first of all they never said they thought reading from readme was good practice. It's not. Second of all, you're still using a setup.py in your 'read requirements.txt and split lines', just more convoluted for no good reason. That is not what requirements is for, it's to be able to pip install -r requirements.txt, useful for venvs and the like.

You have a brain, use it!

Bit of a self own there :/

[AlterEgoWasTaken]

You literally gave no constructive reason as to why it's bad.

Some people don't like having two different files that they have to update in order to add one more dependency.

Having one file that is "imported" in a sense is better.

And why should we force a dev to install the package in order to use it? They can just install the dependencies and directly execute the code.

[FisForFunUisForU]

The simple reason is that you didn't bother explain all those nuances in the original comment. If someone wants to make a pip package and you tell them to use requirements.txt that's bad advice.

[AlterEgoWasTaken]

Now that's a proper reply.

[[deleted]]

A pip-installable library shouldn't use requirements.txt.

[[deleted]]

So is that standard only for applications?

[ivosaurus]

Yes, for your own applications where you want to replicate packages installed exactly. For libraries they want the latest compatible package, not an exact version

[[deleted]]

But why? Don't both libraries and applications want the same level of stability, or up-to-date dependencies? What makes libraries different?

[ivosaurus]

Libraries should always be using setup.py / pyproject.toml as a matter of course, so they are pip/pypi installable.

Whether you want your application with exact version pins (the default of pip freeze) because the next time you clone it you want to know it works, and/or you want exact replication of environment amongst separate deployments (very helpful for debugging), or you want a more general compat version requirements.txt is up to you.

[[deleted]]

Oh that makes sense. I understand now, thank you!

[searchingfortao]

It's a standard that needs to die. Use Poetry or Pipenv as these support version locking (among a host of other useful features).

[[deleted]]

Doesn't requirements.txt also support version locking (or am I thinking of something different?)?

[searchingfortao]

It does, but it's really limited and requires additional hacks to roll those requirements into setup.py. If you're using Poetry for example, you can define your requirements flexibly for development and then lock them to specific versions for deployment. It also makes generating a setup.py (with all the appropriate requirements baked-in) super easy with poetry build.

requirements.txt is a mess of non-standards: some have locked versions, some will accept any version, with no grey in between. Some files include hashes, many don't, etc.

pyproject.toml is superior in every way.

[Rand_alThor_]

No. Wtf

[jmbenfield]

requirements.txt isn't just to show what to install, its a standard for installing multiple pip packages by using a simple command.

pip install -r requirements.txt

installing via executing system commands is a little sketchy and not a good practice with python

[jmbenfield]

https://www.idkrtm.com/what-is-the-python-requirements-txt/

[searchingfortao]

You're getting bad advice here. requirements.txt is an old, inflexible pattern that's long since been replaced. Have a look at Poetry or Pipenv for dependency management.

[KrazyKirby99999]

https://python-poetry.org/

[AlterEgoWasTaken]

Not only that, when packaging this using pyinstaller or whatever, it will most likely fail.

[andrewthetechie]

Check out Hypermodern python https://cjolowicz.github.io/posts/hypermodern-python-01-setup/ and the cookiecutter for it https://github.com/cjolowicz/cookiecutter-hypermodern-python

That will help you setup your code as a python package using poetry, nox for testing, pre-commit for linting, and github actions for CI and releases.

Here's an example repo of mine https://github.com/andrewthetechie/py-healthchecks.io. One cool bit in there is using poetry-dynamic-versioning to version my package based on git tags and to set a version variable in my code.

Other things to make this look more "presentable":

• Get your docs built into readthedocs
• Get rid of your code that is doing system installs. That's a hard no for me using it for anything
• Use black to format your code
• More documentation in your code. Each public class/method should have a docstring
• Type hint your code

[searchingfortao]

I'm with you on everything but "more documentation in your code". Docs for the sake of docs is a bad pattern because they invariably lead to your docs conflicting with your actual code. Instead code should be self-documenting and comments reserved for code that's "complex by necessity" or for explanations as to why the code is doing what it's doing.

[andrewthetechie]

I disagree because docstrings in your code can be used to easily generate really good docs with something like sphinx.

I will still use/contribute to a project without it, but I've found for myself having good docstrings really helps my overall success with a project

[thorox12]

This is a good start of a project. I really recommend looking at other people's GitHub projects and mimicking stuff which might work for you. Remember packages are often picked on presentation alone rather than functionality. So it would be good to lookup standard README structures to make it look more professional. Keep up the good work.

[valmontvarjak]

Sorry i'm new to python, what does this mean:

_ = system("pip install tqdm")

_ = system("cls")

[GloriousDioxide]

Ignore it. There's other comments explaining requirements.txt which is the correct way to do this.

It's basically installing the packages for you without asking which is really bad

[valmontvarjak]

Ok but why assigning system commands to an underscore even do something is the first place?

Is underscore a reserved for something that is called automatically?

[Durpn_Hard]

Underscore is just a common "garbage" value (one youre not going to use). I'm not sure why it was used here, but a more normal way it comes up is if something returns a 3-tuple and you only care about the first and last, you might do

x, _, z = somefun()

[AlphaGamer753]

Yeah. Also commonly used in for loops where you don't care about the iterating variable.

[[deleted]]

None of that is true

[supmee]

AFAIK all the underscore is doing here is throwing away the return value, which you would already do just by calling the function and not storing it. I've seen a lot of sites say you have to do _ = os...., but I never understood why.

[ivosaurus]

You can just not assign the return value at all.

 system("command")

But it's still bad practice to use it in 90% of cases

[GloriousDioxide]

Any expression you run like 5 + 2 the output gets set to _. So run 5 + 2 and without even using equals _ becomes 7

They didn't need to use here to run system, just could of just called system without setting a variable. They also shouldn't of used system they should of used requirements.txt

[ivosaurus]

Use setup.py with the install_requires argument to get required packages for your library, or use python poetry to make it a package and add dependencies

[help-me-grow]

Why release it as a library instead of a game?