diff --git a/feature-flags/.gitignore b/feature-flags/.gitignore new file mode 100644 index 00000000..329cf0f1 --- /dev/null +++ b/feature-flags/.gitignore @@ -0,0 +1,6 @@ +*.db +*.py[cod] +.idea +.web +__pycache__/ +venv/** \ No newline at end of file diff --git a/feature-flags/alembic.ini b/feature-flags/alembic.ini new file mode 100644 index 00000000..1e8c2582 --- /dev/null +++ b/feature-flags/alembic.ini @@ -0,0 +1,116 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts +script_location = alembic + +# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s +# Uncomment the line below if you want the files to be prepended with date and time +# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file +# for all available tokens +# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s + +# sys.path path, will be prepended to sys.path if present. +# defaults to the current working directory. +prepend_sys_path = . + +# timezone to use when rendering the date within the migration file +# as well as the filename. +# If specified, requires the python-dateutil library that can be +# installed by adding `alembic[tz]` to the pip requirements +# string value is passed to dateutil.tz.gettz() +# leave blank for localtime +# timezone = + +# max length of characters to apply to the +# "slug" field +# truncate_slug_length = 40 + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + +# set to 'true' to allow .pyc and .pyo files without +# a source .py file to be detected as revisions in the +# versions/ directory +# sourceless = false + +# version location specification; This defaults +# to alembic/versions. When using multiple version +# directories, initial revisions must be specified with --version-path. +# The path separator used here should be the separator specified by "version_path_separator" below. +# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions + +# version path separator; As mentioned above, this is the character used to split +# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep. +# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas. +# Valid values for version_path_separator are: +# +# version_path_separator = : +# version_path_separator = ; +# version_path_separator = space +version_path_separator = os # Use os.pathsep. Default configuration used for new projects. + +# set to 'true' to search source files recursively +# in each "version_locations" directory +# new in Alembic version 1.10 +# recursive_version_locations = false + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 + +sqlalchemy.url = driver://user:pass@localhost/dbname + + +[post_write_hooks] +# post_write_hooks defines scripts or Python functions that are run +# on newly generated revision scripts. See the documentation for further +# detail and examples + +# format using "black" - use the console_scripts runner, against the "black" entrypoint +# hooks = black +# black.type = console_scripts +# black.entrypoint = black +# black.options = -l 79 REVISION_SCRIPT_FILENAME + +# lint with attempts to fix using "ruff" - use the exec runner, execute a binary +# hooks = ruff +# ruff.type = exec +# ruff.executable = %(here)s/.venv/bin/ruff +# ruff.options = --fix REVISION_SCRIPT_FILENAME + +# Logging configuration +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARN +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARN +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/feature-flags/alembic/README b/feature-flags/alembic/README new file mode 100644 index 00000000..98e4f9c4 --- /dev/null +++ b/feature-flags/alembic/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/feature-flags/alembic/env.py b/feature-flags/alembic/env.py new file mode 100644 index 00000000..36112a3c --- /dev/null +++ b/feature-flags/alembic/env.py @@ -0,0 +1,78 @@ +from logging.config import fileConfig + +from sqlalchemy import engine_from_config +from sqlalchemy import pool + +from alembic import context + +# this is the Alembic Config object, which provides +# access to the values within the .ini file in use. +config = context.config + +# Interpret the config file for Python logging. +# This line sets up loggers basically. +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +# add your model's MetaData object here +# for 'autogenerate' support +# from myapp import mymodel +# target_metadata = mymodel.Base.metadata +target_metadata = None + +# other values from the config, defined by the needs of env.py, +# can be acquired: +# my_important_option = config.get_main_option("my_important_option") +# ... etc. + + +def run_migrations_offline() -> None: + """Run migrations in 'offline' mode. + + This configures the context with just a URL + and not an Engine, though an Engine is acceptable + here as well. By skipping the Engine creation + we don't even need a DBAPI to be available. + + Calls to context.execute() here emit the given string to the + script output. + + """ + url = config.get_main_option("sqlalchemy.url") + context.configure( + url=url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + ) + + with context.begin_transaction(): + context.run_migrations() + + +def run_migrations_online() -> None: + """Run migrations in 'online' mode. + + In this scenario we need to create an Engine + and associate a connection with the context. + + """ + connectable = engine_from_config( + config.get_section(config.config_ini_section, {}), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + ) + + with connectable.connect() as connection: + context.configure( + connection=connection, target_metadata=target_metadata + ) + + with context.begin_transaction(): + context.run_migrations() + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() diff --git a/feature-flags/alembic/script.py.mako b/feature-flags/alembic/script.py.mako new file mode 100644 index 00000000..fbc4b07d --- /dev/null +++ b/feature-flags/alembic/script.py.mako @@ -0,0 +1,26 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} diff --git a/feature-flags/alembic/versions/603ec3b5d217_.py b/feature-flags/alembic/versions/603ec3b5d217_.py new file mode 100644 index 00000000..94d874e7 --- /dev/null +++ b/feature-flags/alembic/versions/603ec3b5d217_.py @@ -0,0 +1,34 @@ +"""empty message + +Revision ID: 603ec3b5d217 +Revises: +Create Date: 2023-11-16 15:26:53.289231 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +import sqlmodel + +# revision identifiers, used by Alembic. +revision: str = '603ec3b5d217' +down_revision: Union[str, None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('featureflags', + sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=False), + sa.Column('value', sqlmodel.sql.sqltypes.AutoString(), nullable=False), + sa.PrimaryKeyConstraint('name') + ) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_table('featureflags') + # ### end Alembic commands ### diff --git a/feature-flags/assets/favicon.ico b/feature-flags/assets/favicon.ico new file mode 100644 index 00000000..166ae995 Binary files /dev/null and b/feature-flags/assets/favicon.ico differ diff --git a/feature-flags/feature_flags/__init__.py b/feature-flags/feature_flags/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/feature-flags/feature_flags/feature_flags.py b/feature-flags/feature_flags/feature_flags.py new file mode 100644 index 00000000..bb0d3bff --- /dev/null +++ b/feature-flags/feature_flags/feature_flags.py @@ -0,0 +1,221 @@ +import copy +import re + +from fastapi import HTTPException +from typing import Optional + +import reflex as rx +from sqlmodel import Field + + +class FeatureFlags(rx.Model, table=True): + name: str = Field(primary_key=True) + value: str = Field() + + +class FeatureFlagsState(rx.State): + feature_flags_as_loaded_from_db: Optional[dict[str, str]] = None + + pending_creates_or_updates: dict[str, str] = {} + pending_deletes: set[str] = set() + + @rx.var + def save_button_color(self) -> str: + if self.pending_creates or self.pending_deletes or self.pending_updates: + return "red" + else: + return "" + + def load_feature_flags_from_db(self): + """Populates self.feature_flags_as_loaded_from_db""" + with rx.session() as session: + feature_flags = session.exec(FeatureFlags.select).all() + self.feature_flags_as_loaded_from_db = {ff.name: ff.value for ff in feature_flags} + + @rx.var + def feature_flag_name_value_pairs(self) -> list[tuple[str, str]]: + if self.feature_flags_as_loaded_from_db is None: + self.load_feature_flags_from_db() + + return sorted([(flag_name, flag_value) for flag_name, flag_value in self.latest_feature_flags_view().items()]) + + def latest_feature_flags_view(self) -> dict[str, str]: + latest = {**(self.feature_flags_as_loaded_from_db or {}), **self.pending_creates_or_updates} + for k in self.pending_deletes: + del latest[k] + return latest + + @rx.var + def pending_creates(self) -> set[str]: + result = set(copy.deepcopy(self.latest_feature_flags_view())) + for k in self.feature_flags_as_loaded_from_db or {}: + if k in result: + result.remove(k) + for k in self.pending_deletes: + if k in result: + result.remove(k) + return result + + @rx.var + def pending_updates(self) -> set[str]: + result = set() + for k in self.feature_flags_as_loaded_from_db or {}: + if k in self.pending_creates_or_updates: + result.add(k) + for k in self.pending_deletes: + if k in result: + result.remove(k) + return result + + def update_feature_flag(self, k: str, val: str): + self.pending_creates_or_updates[k] = val + + def save_to_db(self): + with rx.session() as session: + for k, v in self.pending_creates_or_updates.items(): + if k not in self.pending_deletes: + # TODO: Do we have to select the item before updating it? + ff = session.exec(FeatureFlags.select.where(FeatureFlags.name == k)).first() + if not ff: + ff = FeatureFlags(name=k, value=v) + else: + ff.value = v + session.add(ff) + + for k in self.pending_deletes: + # TODO: Do we have to select the item before deleting it? + ff = session.exec(FeatureFlags.select.where(FeatureFlags.name == k)).first() + if ff: + session.delete(ff) + session.commit() + self.pending_deletes = set() + self.pending_creates_or_updates = {} + self.load_feature_flags_from_db() + + def stage_delete_feature_flag(self, k: str): + self.pending_deletes.add(k) + + +class CreateFlagModalState(FeatureFlagsState): + new_flag_modal_is_open: bool = False + new_flag_modal_error: Optional[str] = None + + def new_flag_modal_cancel(self): + self.reset() + + def handle_submit(self, data): + flag_name = data["flag_name"] + flag_value = data["flag_value"] + if re.search(r"[^a-zA-Z0-9_]+",flag_name): + self.new_flag_modal_error = "Flag name must be contain only one or more alphanumeric or _ chars" + return + if flag_name in self.latest_feature_flags_view(): + self.new_flag_modal_error = "Flag already exists" + return + self.pending_creates_or_updates[flag_name] = flag_value + self.reset() + + +def index() -> rx.Component: + return rx.fragment( + rx.color_mode_button(rx.color_mode_icon(), float="right"), + rx.vstack( + rx.heading("Flex-Flags", font_size="2em"), + rx.hstack( + rx.button("Save", on_click=FeatureFlagsState.save_to_db, color=FeatureFlagsState.save_button_color), + rx.button("Add new", on_click=CreateFlagModalState.set_new_flag_modal_is_open(True)), + ), + rx.cond(FeatureFlagsState.pending_deletes, + rx.text(f"Pending deletes: {FeatureFlagsState.pending_deletes}", color="red")), + rx.cond(FeatureFlagsState.pending_creates, + rx.text(f"Pending creates: {FeatureFlagsState.pending_creates}", color="red")), + rx.cond(FeatureFlagsState.pending_updates, + rx.text(f"Pending updates: {FeatureFlagsState.pending_updates}", color="red")), + rx.modal( + rx.modal_overlay( + rx.modal_content( + rx.modal_header("Add new feature flag"), + + rx.modal_body( + "Add a new feature flag", + rx.form( + rx.vstack( + rx.input( + placeholder="Flag name", + name="flag_name", + ), + rx.input( + placeholder="Flag value", + name="flag_value", + ), + rx.hstack( + rx.button("Stage", type_="submit"), + rx.button("Cancel", on_click=CreateFlagModalState.new_flag_modal_cancel)) + ), + on_submit=CreateFlagModalState.handle_submit, + reset_on_submit=True, + ), + rx.cond(CreateFlagModalState.new_flag_modal_error, + rx.text(CreateFlagModalState.new_flag_modal_error, color="red")) + ), + ) + ), + is_open=CreateFlagModalState.new_flag_modal_is_open, + ), + rx.table( + rx.thead( + rx.tr( + rx.th("Flag name"), + rx.th("Flag value"), + ) + ), + rx.tbody( + rx.cond( + # TODO follow up on "flashing" issue (needs is_hydrated cond right now...) + # Repro sequence: + # 1. Add a new flag X + # 2. Save + # 3. Open new tab T + # 4. from T, delete flag X, save + # 5. refresh T (see flash of X in browser) + # 6. refresh T again (see flash again!) + FeatureFlagsState.is_hydrated, + rx.foreach( + FeatureFlagsState.feature_flag_name_value_pairs, + lambda p: rx.tr( + rx.td(p[0]), + rx.td( + rx.input(value=p[1], + on_change=lambda v: FeatureFlagsState.update_feature_flag(p[0], v), + width="70%")), + rx.td(rx.button("Delete", + on_click=FeatureFlagsState.stage_delete_feature_flag(p[0]), + width="30%")) + ), + ), + ) + ), + ), + on_mount=FeatureFlagsState.load_feature_flags_from_db, + ), + ) + + +app = rx.App() + + +async def get_flag(flag_name: str): + try: + with rx.session() as session: + flag = session.exec(FeatureFlags.select.where(FeatureFlags.name == flag_name)).first() + if flag is None: + raise ValueError() + except Exception: + raise HTTPException(status_code=404, detail="Flag not found") + return {"flag_value": flag.value} + + +app.api.add_api_route("/flag/{flag_name}", get_flag) + +app.add_page(index) +app.compile() diff --git a/feature-flags/reading_feature_flag_example.py b/feature-flags/reading_feature_flag_example.py new file mode 100644 index 00000000..c7f2146c --- /dev/null +++ b/feature-flags/reading_feature_flag_example.py @@ -0,0 +1,17 @@ +import time + +import requests + + +def get_feature_flag(name: str) -> str: + response = requests.get("http://localhost:8000/flag/" + name) + if response.status_code == 404: + return None + return response.json()['flag_value'] + + +if __name__ == '__main__': + while True: + what_is_it = get_feature_flag("THANKSGIVING_DINNER") + print("What's cooking? " + (what_is_it or "Nothing yet")) + time.sleep(3) diff --git a/feature-flags/requirements.txt b/feature-flags/requirements.txt new file mode 100644 index 00000000..bd25a1fc --- /dev/null +++ b/feature-flags/requirements.txt @@ -0,0 +1,2 @@ +reflex>=0.3.2 +requests diff --git a/feature-flags/rxconfig.py b/feature-flags/rxconfig.py new file mode 100644 index 00000000..d7b2a516 --- /dev/null +++ b/feature-flags/rxconfig.py @@ -0,0 +1,7 @@ +import reflex as rx + +config = rx.Config( + app_name="feature_flags", + db_url="sqlite:///reflex.db", +) +