typing and generics

Author: imashwini09

.gitignore

@@ -0,0 +1,135 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.sof
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# OS
+Thumbs.db
+.DS_Store

Pydantic_tutorial/lecture_5.py

@@ -0,0 +1,53 @@
+from pydantic import BaseModel, ValidationError, Field
+from datetime import datetime, UTC
+from functools import partial
+from typing import Literal,Annotated
+
+class User(BaseModel):
+    uid : Annotated[int, Field(gt=0)]
+    username : Annotated[str, Field(min_length=3, max_length=20)]
+    email : str
+    age : Annotated[int, Field(ge=13,le=130)]
+
+    verified_at : datetime | None = None
+
+    bio : str = ""
+    is_active : bool = True
+
+    full_name : str | None = None
+
+class BlogPost(BaseModel):
+    title : Annotated[str, Field(min_length=1,max_length=200)]
+    content : Annotated[str, Field(min_length=20)]
+    view_count : int = 0
+    is_published : bool = False
+
+    tags : list[str] = Field(default_factory=list)
+
+    # create_at : datetime = Field(default_factory=lambda : datetime.now(tz=UTC))
+    # both will do same work lambda or partial function
+    create_at : datetime = Field(default_factory=partial(datetime.now,tz=UTC))
+
+    author_id : str | int
+    status : Literal["draft", "published", "archived"] = "draft"
+
+    slug : Annotated[str, Field(pattern=r"^[a-z0-9-]+$")]
+
+
+try:
+    user = User(
+        uid = 0,
+        username="cs",
+        email="ashwini@gmail.com",
+        age=12
+
+    )
+except ValidationError as e:
+    print(e)
+# post = BlogPost(
+#     title="Getting started with Python",
+#     content="python is dynamically typing language.",
+#     author_id="123",
+# )
+
+# print(post)

Pydantic_tutorial/lecture_6.py

@@ -0,0 +1,53 @@
+from pydantic import BaseModel, ValidationError, Field, EmailStr
+from datetime import datetime, UTC
+from functools import partial
+from typing import Literal,Annotated
+
+class User(BaseModel):
+    uid : Annotated[int, Field(gt=0)]
+    username : Annotated[str, Field(min_length=3, max_length=20)]
+    email : str
+    age : Annotated[int, Field(ge=13,le=130)]
+
+    verified_at : datetime | None = None
+
+    bio : str = ""
+    is_active : bool = True
+
+    full_name : str | None = None
+
+class BlogPost(BaseModel):
+    title : Annotated[str, Field(min_length=1,max_length=200)]
+    content : Annotated[str, Field(min_length=20)]
+    view_count : int = 0
+    is_published : bool = False
+
+    tags : list[str] = Field(default_factory=list)
+
+    # create_at : datetime = Field(default_factory=lambda : datetime.now(tz=UTC))
+    # both will do same work lambda or partial function
+    create_at : datetime = Field(default_factory=partial(datetime.now,tz=UTC))
+
+    author_id : str | int
+    status : Literal["draft", "published", "archived"] = "draft"
+
+    slug : Annotated[str, Field(pattern=r"^[a-z0-9-]+$")]
+
+
+try:
+    user = User(
+        uid = 0,
+        username="cs",
+        email="ashwini@gmail.com",
+        age=12
+
+    )
+except ValidationError as e:
+    print(e)
+# post = BlogPost(
+#     title="Getting started with Python",
+#     content="python is dynamically typing language.",
+#     author_id="123",
+# )
+
+# print(post)

Typing_Generics/lec_1.py

@@ -0,0 +1,12 @@
+age: int = 1
+
+a : int
+
+# a = input()
+
+child: bool
+if age < 18:
+    child = True
+else:
+    child = False
+

Typing_Generics/lec_2.py

@@ -0,0 +1,18 @@
+x1: int = 1
+x2: float = 1.0
+x3: bool = True
+x4: str = "test"
+x5: bytes = b"test"
+
+# For collections on Python 3.9+, the type of the collection item is in brackets
+x6: list[int] = [1]
+x7: set[int] = {6, 7}
+
+# For mappings, we need the types of both keys and values
+x8: dict[str, float] = {"field": 2.0}  # Python 3.9+
+
+# For tuples of fixed size, we specify the types of all the elements
+x9: tuple[int, str, float] = (3, "yes", 7.5)  # Python 3.9+
+
+# For tuples of variable size, we use one type and ellipsis
+x0: tuple[int, ...] = (1, 2, 3) 

Typing_Generics/lec_3.py

@@ -0,0 +1,24 @@
+from typing import List, Set, Dict, Tuple
+x0: List[int] = [1]
+x1: Set[int] = {6, 7}
+x2: Dict[str, float] = {"field": 2.0}
+x3: Tuple[int, str, float] = (3, "yes", 7.5)
+x4: Tuple[int, ...] = (1, 2, 3)
+
+from typing import Union, Optional
+
+# On Python 3.10+, use the | operator when something could be one of a few types
+x5: list[int | str] = [3, 5, "test", "fun"]  # Python 3.10+
+# On earlier versions, use Union
+x6: list[Union[int, str]] = [3, 5, "test", "fun"]
+
+# Use X | None for a value that could be None on Python 3.10+
+# Use Optional[X] on 3.9 and earlier; Optional[X] is the same as 'X | None'
+x7: str | None = "something" if 1 == 1 else None
+if x7 is not None:
+    # Mypy understands x won't be None here because of the if-statement
+    print(x7.upper())
+# If you know a value can never be None due to some logic that mypy doesn't
+# understand, use an assert
+assert x7 is not None
+print(x7.upper())

Typing_Generics/lec_4.py

@@ -0,0 +1,25 @@
+"""
+Meta class
+"""
+from typing import ClassVar, TypeVar
+
+S = TypeVar("S")
+
+class M(type):
+    count: ClassVar[int] = 0
+
+    def make(cls: type[S]) -> S:
+        M.count += 1
+        return cls()
+
+class A(metaclass=M):
+    pass
+
+a: A = A.make()  # make() is looked up at M; the result is an object of type A
+print(A.count)
+
+class B(A):
+    pass
+
+b: B = B.make()  # metaclasses are inherited
+# print(B.count + " objects were created") 

Typing_Generics/lec_5.py

@@ -0,0 +1,17 @@
+from typing import TypeVar, Generic
+
+T = TypeVar('T')  # Define type variable "T"
+
+class Stack(Generic[T]):
+    def __init__(self) -> None:
+        # Create an empty list with items of type T
+        self.items: list[T] = []
+
+    def push(self, item: T) -> None:
+        self.items.append(item)
+
+    def pop(self) -> T:
+        return self.items.pop()
+
+    def empty(self) -> bool:
+        return not self.items

adv python/metaclass_example.py

@@ -0,0 +1,15 @@
+class NamingConventionMeta(type):
+    def __new__(cls, name, bases, attrs):
+        if not name.startswith("My"):
+            raise ValueError("Class name must start with 'My'")
+        # Add a default method
+        attrs["get_class_name"] = lambda self: name
+        return super().__new__(cls, name, bases, attrs)
+
+class MyCalculator(metaclass=NamingConventionMeta):
+    def add_numbers(self, a, b):
+        return a + b
+
+# This will raise ValueError
+# class Calculator(metaclass=NamingConventionMeta):
+#     pass

adv python/string_intern.py

@@ -0,0 +1,16 @@
+# Example of string interning
+a = "hello"
+b = "hello"
+print(a is b)  # True (interned, same memory address)
+print(id(a))
+print(id(b))
+
+c = "hello world" * 100  # Runtime-generated string
+d = "hello world" * 100
+print(c is d)  # False (not interned, different objects)
+
+# Explicit interning
+import sys
+c_interned = sys.intern(c)
+d_interned = sys.intern(d)
+print(c_interned is d_interned)  # True (interned explicitly)