probable-fiesta 0.2.5

Description:

probablefiesta 0.2.5

probable-fiesta


There's probably a fiesta somewhere.

Python Package Core
A Python package core for building a Python package.
Installation
Installation using pip
pip install probable-fiesta

Installation with automatic build and install

It is recommended to setup a virtual environment.

To install locally with automatic build and install, run the following command in the root directory of the project.
git clone https://github.com/sergio-munoz/probable-fiesta.git
cd probable-fiesta
chmod +x scripts/build_install.sh
./scripts/build_install.sh

Installation with manual build and install
Setup a new virtual environment and install packages in requirements.txt.
python -m venv build_venv
source build_venv/bin/activate
(build_venv) $ pip install -r build_requirements.txt
(build_venv) $ hatch build
(build_venv) $ pip install dist/probable_fiesta-${VERSION}.tar.gz

Installation in Jupyter Notebook
To install the into the Jupyter Notebook kernel:
import sys
!{sys.executable} -m pip install -U --no-deps probable-fiesta

Usage
probable_fiesta --help

Build and Run
Build and Run command
Build and a command. Pass flags, for example --version:
./scripts/build_install.sh & probable_fiesta --version

Tests
Automatic
./scripts/test_coverage.sh

Developer Reference
This package contains various modules that can be used to build a Python package.
Modules

probable_fiesta: Main module.
probable_fiesta.app: Main application.
probable_fiesta.app.main: Main application.
probable_fiesta.cli: Command line interface.
probable_fiesta.command: Internal command implementation.
probable_fiesta.config: Configuration.
probable_fiesta.logger: Logging.

Create Application Example
Create a new application using the probable_fiesta package.

Create a main module, for example main.py:

# Path: main.py
from probable_fiesta.config.variables import DotEnvDef
from probable_fiesta.config.builder.config_builder import ConfigBuilder
from probable_fiesta.logger.builder.logger_factory import LoggerFactory
from probable_fiesta.app.builder.context_factory import ContextFactory as CF
from probable_fiesta.app.builder.app_builder import AppBuilder

# Import or add your business logic here
# For example the next get version functions:
def get_version_echo(version):
return version
def get_version():
return "v0"

# Create custom dotenv definition from DotEnvDef
class MyDotEnvDef(DotEnvDef):
def __init__(self):
super().__init__()
self.version_echo = "v0" # This will be overwritten by .env file

# make the class iterable
def __iter__(self):
for attr, value in self.__dict__.items():
yield value # only yield the values

# Create main function
def main(args):
# Create config, will be replaced by a Factory in the future
cB = ConfigBuilder()
config = (
cB.logger.set_logger(
LoggerFactory.new_logger_get_logger("main_app", "INFO")
)
.dotenv.load_dotenv() # Load .env file if exists
.set_vars(MyDotEnvDef())
.build()
)

# Create main app
main_app = (
aB.name.set_name("main_app")
.arguments.set_arguments(args)
# Add your arguments
.args_parser.add_argument(
"--version", action="store_true", help="show version builder"
)
# Add your commands that do not require parsed arguments
.context.add_context(
CF.new_context_one_new_command("version", "version", get_version, None)
)
# Define which are executable
.set_executables(["version"])
.config.set_config(config)
.validate()
.build()
)

# Create commands that require parsed arguments
c3 = CF.new_context_one_new_command(
"--version-echo",
"version_echo",
get_version_echo,
main_app.get_arg("version_echo"), # CLI overrides .env
)
# Add commands to main app
main_app.context.add_context(c3)

# Check build errors
if main_app.args_parser.error:
print(main_app.args_parser.error)
return

# Run main app
run_context = main_app.run()
history = run_context.get_run_history()
print(history)
return history

This allows you to call the main function from the command line:
python main.py --version