From 7568154ad9a9fbfaf96b41bca87d5dbcf3274081 Mon Sep 17 00:00:00 2001 From: Duncan Kibet Date: Wed, 28 May 2025 06:55:48 +0300 Subject: [PATCH 1/7] create migration --- alembic.ini | 105 ++++++++++++++++++ alembic/README | 1 + alembic/env.py | 78 +++++++++++++ alembic/script.py.mako | 24 ++++ .../f4b9ba6d292a_create_freebies_table.py | 35 ++++++ 5 files changed, 243 insertions(+) create mode 100644 alembic.ini create mode 100644 alembic/README create mode 100644 alembic/env.py create mode 100644 alembic/script.py.mako create mode 100644 alembic/versions/f4b9ba6d292a_create_freebies_table.py diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 000000000..ac4af2719 --- /dev/null +++ b/alembic.ini @@ -0,0 +1,105 @@ +# 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. + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 + +sqlalchemy.url = sqlite:///instance/app.db + + +[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 + +# 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/alembic/README b/alembic/README new file mode 100644 index 000000000..98e4f9c44 --- /dev/null +++ b/alembic/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/alembic/env.py b/alembic/env.py new file mode 100644 index 000000000..6626bfd0c --- /dev/null +++ b/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/alembic/script.py.mako b/alembic/script.py.mako new file mode 100644 index 000000000..55df2863d --- /dev/null +++ b/alembic/script.py.mako @@ -0,0 +1,24 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision = ${repr(up_revision)} +down_revision = ${repr(down_revision)} +branch_labels = ${repr(branch_labels)} +depends_on = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} diff --git a/alembic/versions/f4b9ba6d292a_create_freebies_table.py b/alembic/versions/f4b9ba6d292a_create_freebies_table.py new file mode 100644 index 000000000..7db156b02 --- /dev/null +++ b/alembic/versions/f4b9ba6d292a_create_freebies_table.py @@ -0,0 +1,35 @@ +"""create freebies table + +Revision ID: f4b9ba6d292a +Revises: +Create Date: 2025-05-28 06:45:20.608435 + +""" +from alembic import op +import sqlalchemy as sa + + +revision = 'f4b9ba6d292a' +down_revision = None +branch_labels = None +depends_on = None + + +def upgrade() -> None: + op.create_table('freebies', + sa.Column('id', sa.Integer(), nullable=False, primary_key=True), + sa.Column('item_name', sa.String(), nullable=False), + sa.Column('value', sa.Integer(), nullable=False), + sa.Column('company_id', sa.Integer(), sa.ForeignKey('companies.id'), nullable=False), + sa.Column('dev_id', sa.Integer(), sa.ForeignKey('devs.id'), nullable=False), + sa.PrimaryKeyConstraint('id') + ) + + op.create_index(op.f('ix_freebies_company_id'), 'freebies', ['company_id']) + op.create_index(op.f('ix_freebies_dev_id'), 'freebies', ['dev_id']) + + +def downgrade() -> None: + op.drop_index(op.f('ix_freebies_dev_id'), table_name='freebies') + op.drop_index(op.f('ix_freebies_company_id'), table_name='freebies') + op.drop_table('freebies') From 6254507f86b82dd058a9228c078c482b2ffc0818 Mon Sep 17 00:00:00 2001 From: Duncan Kibet Date: Wed, 28 May 2025 07:43:02 +0300 Subject: [PATCH 2/7] Add base Company and Dev models with SQLAlchemy --- lib/models.py | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/lib/models.py b/lib/models.py index 2681bee5a..a530f8236 100644 --- a/lib/models.py +++ b/lib/models.py @@ -1,12 +1,11 @@ from sqlalchemy import ForeignKey, Column, Integer, String, MetaData from sqlalchemy.orm import relationship, backref from sqlalchemy.ext.declarative import declarative_base - +from sqlalchemy.ext.associationproxy import association_proxy convention = { "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s", } metadata = MetaData(naming_convention=convention) - Base = declarative_base(metadata=metadata) class Company(Base): @@ -16,10 +15,32 @@ class Company(Base): name = Column(String()) founding_year = Column(Integer()) + freebies = relationship('Freebie', back_populates='company', cascade='all, delete-orphan') + + devs = association_proxy('freebies', 'dev') + creator= lambda dev: Freebie(dev=dev) + def __repr__(self): return f'' + + def give_freebie(self, dev, item_name, value): + freebie = Freebie( + item_name=item_name, + value=value, + company=self, + dev=dev + ) + return freebie + + @classmethod + def oldest_company(cls): + return cls.quert.order_by(cls.founding_year).first() + + + + -class Dev(Base): + class Dev(Base): __tablename__ = 'devs' id = Column(Integer(), primary_key=True) From 68f3c4e6c91a3783ad342cee8d9ea34e503383d6 Mon Sep 17 00:00:00 2001 From: Duncan Kibet Date: Wed, 28 May 2025 07:46:15 +0300 Subject: [PATCH 3/7] Implement Freebie model with relationships to Company and Dev --- lib/models.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lib/models.py b/lib/models.py index a530f8236..469cc769d 100644 --- a/lib/models.py +++ b/lib/models.py @@ -46,5 +46,7 @@ class Dev(Base): id = Column(Integer(), primary_key=True) name= Column(String()) + freebies = relationship('Freebie', back_populates='dev', cascade='all, delete-orphan') + def __repr__(self): return f'' From 068f7dbcfe14febd387a7d644e261827334bed08 Mon Sep 17 00:00:00 2001 From: Duncan Kibet Date: Wed, 28 May 2025 07:54:01 +0300 Subject: [PATCH 4/7] Add relationship properties and association proxies --- lib/models.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/lib/models.py b/lib/models.py index 469cc769d..b58f058cd 100644 --- a/lib/models.py +++ b/lib/models.py @@ -48,5 +48,17 @@ class Dev(Base): freebies = relationship('Freebie', back_populates='dev', cascade='all, delete-orphan') + companies = association_proxy('freebies', 'company') + creator = lambda company: Freebie(company=company) + + def __repr__(self): return f'' + + def received_one(self,item_name): + return any(f.item_name == item_name for f in self.freebies) + + def give_away(self, dev, freebie): + + + From a59e572a7b2bf7a298fe66a0d364456d8d2b90f0 Mon Sep 17 00:00:00 2001 From: Duncan Kibet Date: Wed, 28 May 2025 08:01:33 +0300 Subject: [PATCH 5/7] Implement business logic methods (give_freebie, received_one) --- lib/models.py | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/lib/models.py b/lib/models.py index b58f058cd..5e672960f 100644 --- a/lib/models.py +++ b/lib/models.py @@ -59,6 +59,27 @@ def received_one(self,item_name): return any(f.item_name == item_name for f in self.freebies) def give_away(self, dev, freebie): - + + if freebie in self.freebies: + freebie.dev = dev + return True + return False + +class Freebie(Base): + __tablename__ = 'freebies' + + id = Column(Integer(), primary_key=True) + item_name = Column(String(), nullable=False) + value = Column(Integer(), nullable=False) + + company_id = Column(Integer(), ForeignKey('companies.id'), nullable=False) + dev_id = Column(Integer(), ForeignKey('devs.id'), nullable=False) + + company = relationship('Company', back_populates='freebies') + dev = relationship('Dev', back_populates='freebies') + + def __repr__(self): + return f'' + From c768caeba12a0c2989628bcb79e1a4c725b24530 Mon Sep 17 00:00:00 2001 From: Duncan Kibet Date: Fri, 30 May 2025 08:21:45 +0300 Subject: [PATCH 6/7] Add seed.py and debug.py for testing --- alembic/__pycache__/env.cpython-38.pyc | Bin 0 -> 1619 bytes alembic/config.py | 18 ++++ alembic/env.py | 60 +++---------- lib/__pycache__/__init__.py | 0 lib/__pycache__/models.cpython-38.pyc | Bin 0 -> 3466 bytes lib/debug.py | 49 +++++++++- lib/freebies.db | Bin 20480 -> 28672 bytes lib/migrations/env.py | 55 ++++-------- .../1b5e2cf295ac_initial_migration.py | 57 ++++++++++++ lib/models.py | 85 ++++++++---------- lib/seed.py | 43 ++++++++- 11 files changed, 228 insertions(+), 139 deletions(-) create mode 100644 alembic/__pycache__/env.cpython-38.pyc create mode 100644 alembic/config.py create mode 100644 lib/__pycache__/__init__.py create mode 100644 lib/__pycache__/models.cpython-38.pyc create mode 100644 lib/migrations/versions/1b5e2cf295ac_initial_migration.py diff --git a/alembic/__pycache__/env.cpython-38.pyc b/alembic/__pycache__/env.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39760945e8c65f21c8e32a69c4e0f4ba04d52ec0 GIT binary patch literal 1619 zcmZvc&yO256vyrPnM{6cyFlp$$+smEN|8`GAym46RD@P#X$8t<DBe==82{0j&K&z_{a3rsZ5^RxZl*M1+*^T8lP@cjDY$BU0T2>s?d zH=htXkKi@0pkat%iAp@d*x7*$%5V~TI|MtLMBa{MTqctQBc3eNNy^h@hs7_t`YVo| z{nD+DCtVh^ ze7{mNF^AqRS976wKGRj17h7+%swxSiDR?YDu?Ju$n%i2d!iCvB7>q8w`|z4a&{(v_ z3}4|3WP@dRj%>sN7P3fS7GJ_PZLp57(CeYMk}DAR9eRkqL5Jvj#1fF1(k~(CVXa6h z=9*ejDMN%Jd(~_vLFgVSE5^rJM&Nn25Qem(Yt0R@3+}p3F*z1?L6)_#gp%inU;Ft~ zF`_E)DDs8h_6M+}s^^Pq4}plZDEP|KspNjuf@@BwA;(AH8D-Wwc8z;S%`)Bi!N{=@JS1vLcd zOu-e^q5{lXU>ppNDS%~*>l=uvF;yY_m?K6(VcarN&sEv9X`0=(xVcbb>(h~&)j6o8ds 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. +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +from config import Base +from models import Company, Dev, Freebie - Calls to context.execute() here emit the given string to the - script output. +config = context.config +fileConfig(config.config_file_name) +target_metadata = Base.metadata - """ +def run_migrations_offline(): url = config.get_main_option("sqlalchemy.url") context.configure( url=url, @@ -45,34 +21,24 @@ def run_migrations_offline() -> None: 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. - - """ +def run_migrations_online(): 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 + 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() + run_migrations_online() \ No newline at end of file diff --git a/lib/__pycache__/__init__.py b/lib/__pycache__/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/lib/__pycache__/models.cpython-38.pyc b/lib/__pycache__/models.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29afeee369a39e026f78e758724dbb23d32e714b GIT binary patch literal 3466 zcma)9TW=dh6yBL#+v|<(IO&BuHIxEI#3_`E5Fx5)6>cIgEl7-nR-2u1;$|=I>?YKf zd7+iyrEffekl?X@g`cpmJn_t1g#_Q3wPPnrq;53FbLM*H%=eu+`KsCUEPOk^ytnsf z-Ln27W$|;MTt~@%hLDzIkrgw+VlH@W3p;j%6IVoqQ6G=0aZS`>SGY#Eqk8NK&(xi0 zDQ<`c>J?cXFws;M)s(e|Oth4zTGB;r`4dalrT4&+o?5=>Y(Z}s zeN`^svbycRVVTvf6y8><)nGUILXC>*jWjxllcM%nlB->%i|Vah50c%&{Zi$@%^(lD zyl7|@1^FONvc18usO<#dzE=G%E80?pQJ~RxsQjHEQ)pWWvMdb;X1qVt>AjKQ{r&NW z{eAz+>v^yfDL)Bf)y<%WW^@1Qyanqjt(Ei_M|PQ5!5o<7hiP)C60!wbxiM^%urZ{Q zEq)a!*HJPJp)A3qCAeh5R*tIN#|=pPAs1C>HE52kKy%B!`%Ki8C#$k1U0Hu$w3s6Q;OP_R%&N}N;zTlcr}QkH#<^ADpzZ%9_|InBVM$~{r)f= z9^g(?CTd}jg@IIs+b^dW<(eESj87tw~FHh%O| zRJZgq_<8*K`d%8Vb$O74L9z}DGIeb|Or=^2_h6k$cGdcDl<%d<+VI-i)PS{I!$hUm zqruL4jKNXX8;%NhBMRaj8En$Z|Dago_S8weSrb%sRh*+-D7 zq8J~ZM+H9Q6MJG!7(D5G?@S!y&8}0_2f2z3ri;p95FIGJg7L=5`f1d<75(y2!z)y~ z0#Vea{yS-GW0&YP?R*g@dns8rw=Esj?hIHSm9(%r*Yy z{}mR)7l z|EjiYyB=p|REPn`zN7df(fq{mr@jz%JhgNp>NKWNr#X!}tup3_mH6Huk%% z2_IW}8M34_(Oc7%>vJTGV+fLGle^; z_Fkv+xw3&JI-2mVFOhhO#EDJmNEoR;266Dc@bp%l&G#*XfyIQcm zeh*q{wFx}+ja`+fdqcgsN$ZhC4s07=CVy!aDo|beX`J$xT8!*zBV^4ZMM3JcRIu2(e$)=O=8!efa7Y;;r$} z?JXE!U_{XB+NCiDX0M{*#5EOl6O@AQg3)za+=Z~X$EwU><0ct()W6+r>oxT19*K1l zS4og@hVA+-s?F(soawqry_ZRRNP?K;xjf&QNy6!ztZ!_UImVQi26Jce@@w*w zK^~sg>Ac<%H&5qM_ST5M|htx~@BZYTXN$vQ!2T92`{@F1yQ)C;*r^V zfii|Il)H%5d{8gdacK+DQ9QfQqweLsh0I>#{~b$QIx%1&%{N)Td1>juvjkl)(KP2{ rl!}8tVBxGb1N}k6taY&n6{6EL`n8({MwV(SRPLtgg literal 0 HcmV?d00001 diff --git a/lib/debug.py b/lib/debug.py index 4f922eb69..2a2ff1ab5 100644 --- a/lib/debug.py +++ b/lib/debug.py @@ -1,9 +1,52 @@ #!/usr/bin/env python3 from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker +from models import Company, Dev, Freebie, Base -from models import Company, Dev - -if __name__ == '__main__': +def debug_session(): + # Setup database connection engine = create_engine('sqlite:///freebies.db') + Base.metadata.create_all(engine) + + Session = sessionmaker(bind=engine) + session = Session() + + # Create test data + company = Company(name="TestCorp", founding_year=2005) + dev = Dev(name="TestDev") + session.add_all([company, dev]) + session.commit() + + # Create freebie using the session + freebie = Freebie( + item_name="TestItem", + value=50, + company=company, + dev=dev + ) + session.add(freebie) + session.commit() + + # Alternative: If you want to keep using give_freebie method, + # modify your Company class to either: + # 1. Accept session parameter (current implementation), or + # 2. Create its own session internally + + # Debug output + print("Test objects created:") + print(f"- company: {company}") + print(f"- dev: {dev}") + print(f"- freebie: {freebie}") + print("\nTry these commands:") + print("freebie.print_details()") + print("company.freebies") + print("dev.companies") + print("Company.oldest_company(session)") # Now properly passed + print("dev.received_one('TestItem')") + print("dev.give_away(other_dev, freebie, session)") # Added session + import ipdb; ipdb.set_trace() + +if __name__ == '__main__': + debug_session() \ No newline at end of file diff --git a/lib/freebies.db b/lib/freebies.db index 12beb1c963e832db481e7a7493e3029e691ac4dc..462d28ffd14b9192cbd4e64a4ecd7b1df55556c2 100644 GIT binary patch delta 779 zcmZozz}WDBae}lU9|HpeI}o!1F(VLjP1G@#*VE=VqoRrXW-}M-^sIrho5gQ zcjd;$>D*S0Vr=Z<^74$0)g_5ZIjPC{xdn-NnW@Ea2D@{Rt7C|(LWrZ2kE?< zPo^Hkb@ulQ4heDu>Q_k1j)yrW9-$Y?1iDng%|FQ1)7?+O+ci=Hp+Hk1$koj?$kor; zHCO>20ty#2VUlU8QF5A*rD@{k|MFk?Wsn4td4Xwzh5rHr{}=uj z{CD^-Y!(zaz;D3C!ptBYl3HBil3K>ajKpR_VlyJxn*|Nt^G}>0ILU#9gNgqR1OI#e zJ3x~z@S6xSu`$RpGBSb;^8`k%5eo}HBS?so6D|aC!vO~V5Bv}KFYq4#>fFHZz{kSE ZAjWae}lUD+2=q2*UvLL>*&MRtCLzSzi7h3@m(74E((OJNfGQq&5o*EaO#A zW?>f>6=iJHEJ;ktNli&DD+Xa!=O9 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. - - """ +def run_migrations_offline(): + """Run migrations in 'offline' mode (for generate/script output).""" url = config.get_main_option("sqlalchemy.url") context.configure( url=url, target_metadata=target_metadata, literal_binds=True, dialect_opts={"paramstyle": "named"}, + render_as_batch=True ) 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. - - """ +def run_migrations_online(): + """Run migrations in 'online' mode (connects to DB).""" connectable = engine_from_config( config.get_section(config.config_ini_section), prefix="sqlalchemy.", @@ -66,7 +38,10 @@ def run_migrations_online() -> None: with connectable.connect() as connection: context.configure( - connection=connection, target_metadata=target_metadata, render_as_batch=True, + connection=connection, + target_metadata=target_metadata, + render_as_batch=True, + compare_type=True, ) with context.begin_transaction(): @@ -76,4 +51,4 @@ def run_migrations_online() -> None: if context.is_offline_mode(): run_migrations_offline() else: - run_migrations_online() + run_migrations_online() \ No newline at end of file diff --git a/lib/migrations/versions/1b5e2cf295ac_initial_migration.py b/lib/migrations/versions/1b5e2cf295ac_initial_migration.py new file mode 100644 index 000000000..523720631 --- /dev/null +++ b/lib/migrations/versions/1b5e2cf295ac_initial_migration.py @@ -0,0 +1,57 @@ +"""Initial migration + +Revision ID: 1b5e2cf295ac +Revises: 5f72c58bf48c +Create Date: 2025-05-28 20:44:53.602088 + +""" +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision = '1b5e2cf295ac' +down_revision = '5f72c58bf48c' +branch_labels = None +depends_on = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('freebies', + sa.Column('id', sa.Integer(), nullable=False), + sa.Column('item_name', sa.String(), nullable=False), + sa.Column('value', sa.Integer(), nullable=False), + sa.Column('company_id', sa.Integer(), nullable=True), + sa.Column('dev_id', sa.Integer(), nullable=True), + sa.ForeignKeyConstraint(['company_id'], ['companies.id'], name=op.f('fk_freebies_company_id_companies')), + sa.ForeignKeyConstraint(['dev_id'], ['devs.id'], name=op.f('fk_freebies_dev_id_devs')), + sa.PrimaryKeyConstraint('id') + ) + with op.batch_alter_table('companies', schema=None) as batch_op: + batch_op.alter_column('name', + existing_type=sa.VARCHAR(), + nullable=False) + + with op.batch_alter_table('devs', schema=None) as batch_op: + batch_op.alter_column('name', + existing_type=sa.VARCHAR(), + nullable=False) + + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + with op.batch_alter_table('devs', schema=None) as batch_op: + batch_op.alter_column('name', + existing_type=sa.VARCHAR(), + nullable=True) + + with op.batch_alter_table('companies', schema=None) as batch_op: + batch_op.alter_column('name', + existing_type=sa.VARCHAR(), + nullable=True) + + op.drop_table('freebies') + # ### end Alembic commands ### diff --git a/lib/models.py b/lib/models.py index 5e672960f..ec6fd8325 100644 --- a/lib/models.py +++ b/lib/models.py @@ -1,85 +1,76 @@ -from sqlalchemy import ForeignKey, Column, Integer, String, MetaData +from sqlalchemy import Column, Integer, String, ForeignKey from sqlalchemy.orm import relationship, backref -from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.ext.associationproxy import association_proxy -convention = { - "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s", -} -metadata = MetaData(naming_convention=convention) -Base = declarative_base(metadata=metadata) +from sqlalchemy.orm import declarative_base + +Base = declarative_base() class Company(Base): __tablename__ = 'companies' - id = Column(Integer(), primary_key=True) - name = Column(String()) - founding_year = Column(Integer()) - - freebies = relationship('Freebie', back_populates='company', cascade='all, delete-orphan') + id = Column(Integer, primary_key=True) + name = Column(String, nullable=False) + founding_year = Column(Integer) - devs = association_proxy('freebies', 'dev') - creator= lambda dev: Freebie(dev=dev) + freebies = relationship("Freebie", back_populates="company") + devs = association_proxy('freebies', 'dev', + creator=lambda dev: Freebie(dev=dev)) def __repr__(self): return f'' - - def give_freebie(self, dev, item_name, value): + + def give_freebie(self, dev, item_name, value, db_session): freebie = Freebie( item_name=item_name, value=value, company=self, dev=dev ) + db_session.add(freebie) + db_session.commit() return freebie - - @classmethod - def oldest_company(cls): - return cls.quert.order_by(cls.founding_year).first() - - - + @classmethod + def oldest_company(cls, db_session): + return db_session.query(cls).order_by(cls.founding_year).first() - class Dev(Base): +class Dev(Base): __tablename__ = 'devs' - id = Column(Integer(), primary_key=True) - name= Column(String()) - - freebies = relationship('Freebie', back_populates='dev', cascade='all, delete-orphan') - - companies = association_proxy('freebies', 'company') - creator = lambda company: Freebie(company=company) + id = Column(Integer, primary_key=True) + name = Column(String, nullable=False) + freebies = relationship("Freebie", back_populates="dev") + companies = association_proxy('freebies', 'company', + creator=lambda company: Freebie(company=company)) def __repr__(self): return f'' - - def received_one(self,item_name): + + def received_one(self, item_name): return any(f.item_name == item_name for f in self.freebies) - - def give_away(self, dev, freebie): + def give_away(self, dev, freebie, db_session): if freebie in self.freebies: freebie.dev = dev + db_session.commit() return True return False - + class Freebie(Base): __tablename__ = 'freebies' - id = Column(Integer(), primary_key=True) - item_name = Column(String(), nullable=False) - value = Column(Integer(), nullable=False) - - company_id = Column(Integer(), ForeignKey('companies.id'), nullable=False) - dev_id = Column(Integer(), ForeignKey('devs.id'), nullable=False) + id = Column(Integer, primary_key=True) + item_name = Column(String, nullable=False) + value = Column(Integer, nullable=False) + company_id = Column(Integer, ForeignKey('companies.id')) + dev_id = Column(Integer, ForeignKey('devs.id')) - company = relationship('Company', back_populates='freebies') - dev = relationship('Dev', back_populates='freebies') + company = relationship("Company", back_populates="freebies") + dev = relationship("Dev", back_populates="freebies") def __repr__(self): - return f'' - - + return f'' + def print_details(self): + return f"{self.dev.name} owns a {self.item_name} from {self.company.name}" \ No newline at end of file diff --git a/lib/seed.py b/lib/seed.py index b16becbbb..e9336293a 100644 --- a/lib/seed.py +++ b/lib/seed.py @@ -1,3 +1,42 @@ -#!/usr/bin/env python3 +from config import Base, engine, SessionLocal +from models import Company, Dev, Freebie -# Script goes here! +def seed_database(): + Base.metadata.create_all(bind=engine) + db = SessionLocal() + print(" Clearing old data...") + db.query(Freebie).delete() + db.query(Company).delete() + db.query(Dev).delete() + db.commit() + + print("Creating companies...") + companies = [ + Company(name="TechCorp", founding_year=2000), + Company(name="DevSoft", founding_year=1995), + Company(name="CodeMasters", founding_year=2010) + ] + db.add_all(companies) + + print("Creating devs...") + devs = [ + Dev(name="Alice"), + Dev(name="Bob"), + Dev(name="Charlie") + ] + db.add_all(devs) + db.commit() + + print("Creating freebies...") + freebies = [ + Freebie(item_name="T-shirt", value=15, dev=devs[0], company=companies[0]), + Freebie(item_name="Mug", value=10, dev=devs[0], company=companies[1]), + Freebie(item_name="Sticker", value=5, dev=devs[1], company=companies[0]), + Freebie(item_name="Laptop", value=1000, dev=devs[2], company=companies[2]) + ] + db.add_all(freebies) + db.commit() + print("Database seeded successfully!") + +if __name__ == '__main__': + seed_database() \ No newline at end of file From 3827328e5dfe1e480799d678423f80116d5abb0a Mon Sep 17 00:00:00 2001 From: Duncan Kibet Date: Fri, 30 May 2025 08:24:15 +0300 Subject: [PATCH 7/7] Clean up imports --- lib/debug.py | 16 +++++----------- 1 file changed, 5 insertions(+), 11 deletions(-) diff --git a/lib/debug.py b/lib/debug.py index 2a2ff1ab5..d4cbcec48 100644 --- a/lib/debug.py +++ b/lib/debug.py @@ -5,20 +5,20 @@ from models import Company, Dev, Freebie, Base def debug_session(): - # Setup database connection + engine = create_engine('sqlite:///freebies.db') Base.metadata.create_all(engine) Session = sessionmaker(bind=engine) session = Session() - # Create test data + company = Company(name="TestCorp", founding_year=2005) dev = Dev(name="TestDev") session.add_all([company, dev]) session.commit() - # Create freebie using the session + freebie = Freebie( item_name="TestItem", value=50, @@ -28,12 +28,6 @@ def debug_session(): session.add(freebie) session.commit() - # Alternative: If you want to keep using give_freebie method, - # modify your Company class to either: - # 1. Accept session parameter (current implementation), or - # 2. Create its own session internally - - # Debug output print("Test objects created:") print(f"- company: {company}") print(f"- dev: {dev}") @@ -42,9 +36,9 @@ def debug_session(): print("freebie.print_details()") print("company.freebies") print("dev.companies") - print("Company.oldest_company(session)") # Now properly passed + print("Company.oldest_company(session)") print("dev.received_one('TestItem')") - print("dev.give_away(other_dev, freebie, session)") # Added session + print("dev.give_away(other_dev, freebie, session)") import ipdb; ipdb.set_trace()