Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /Pacalexandre_oidc_pure /oidc_pure /models.py
| """Data models for OIDC/OAuth2 responses and configurations.""" | |
| from dataclasses import dataclass, field | |
| from typing import Any | |
| class OIDCConfig: | |
| """OIDC Provider configuration from discovery endpoint.""" | |
| issuer: str | |
| authorization_endpoint: str | |
| token_endpoint: str | |
| userinfo_endpoint: str | |
| jwks_uri: str | |
| end_session_endpoint: str | None = None | |
| scopes_supported: list[str] = field(default_factory=list) | |
| response_types_supported: list[str] = field(default_factory=list) | |
| grant_types_supported: list[str] = field(default_factory=list) | |
| token_endpoint_auth_methods_supported: list[str] = field(default_factory=list) | |
| claims_supported: list[str] = field(default_factory=list) | |
| code_challenge_methods_supported: list[str] = field(default_factory=list) | |
| def from_dict(cls, data: dict[str, Any]) -> "OIDCConfig": | |
| """Create OIDCConfig from discovery response.""" | |
| return cls( | |
| issuer=data["issuer"], | |
| authorization_endpoint=data["authorization_endpoint"], | |
| token_endpoint=data["token_endpoint"], | |
| userinfo_endpoint=data["userinfo_endpoint"], | |
| jwks_uri=data["jwks_uri"], | |
| end_session_endpoint=data.get("end_session_endpoint"), | |
| scopes_supported=data.get("scopes_supported", []), | |
| response_types_supported=data.get("response_types_supported", []), | |
| grant_types_supported=data.get("grant_types_supported", []), | |
| token_endpoint_auth_methods_supported=data.get( | |
| "token_endpoint_auth_methods_supported", [] | |
| ), | |
| claims_supported=data.get("claims_supported", []), | |
| code_challenge_methods_supported=data.get("code_challenge_methods_supported", []), | |
| ) | |
| class TokenResponse: | |
| """OAuth2 token response as per RFC 6749.""" | |
| access_token: str | |
| token_type: str | |
| expires_in: int | None = None | |
| refresh_token: str | None = None | |
| scope: str | None = None | |
| id_token: str | None = None | |
| def from_dict(cls, data: dict[str, Any]) -> "TokenResponse": | |
| """Create TokenResponse from token endpoint response.""" | |
| return cls( | |
| access_token=data["access_token"], | |
| token_type=data["token_type"], | |
| expires_in=data.get("expires_in"), | |
| refresh_token=data.get("refresh_token"), | |
| scope=data.get("scope"), | |
| id_token=data.get("id_token"), | |
| ) | |
| class UserInfo: | |
| """User information from userinfo endpoint.""" | |
| sub: str # Subject identifier | |
| name: str | None = None | |
| given_name: str | None = None | |
| family_name: str | None = None | |
| email: str | None = None | |
| email_verified: bool | None = None | |
| preferred_username: str | None = None | |
| claims: dict[str, Any] = field(default_factory=dict) | |
| def from_dict(cls, data: dict[str, Any]) -> "UserInfo": | |
| """ | |
| Create UserInfo from userinfo endpoint response. | |
| Suporta tanto o formato OIDC padrão quanto providers OAuth2 puros | |
| como GitHub, que usam estruturas diferentes. | |
| Mapeamentos: | |
| - GitHub 'id' -> OIDC 'sub' | |
| - GitHub 'login' -> OIDC 'preferred_username' | |
| """ | |
| # Extract known fields | |
| known_fields = { | |
| "sub", | |
| "name", | |
| "given_name", | |
| "family_name", | |
| "email", | |
| "email_verified", | |
| "preferred_username", | |
| } | |
| # Separate known and unknown claims | |
| known = {k: v for k, v in data.items() if k in known_fields} | |
| unknown = {k: v for k, v in data.items() if k not in known_fields} | |
| # Mapear campos de providers não-OIDC (GitHub, etc) | |
| # GitHub usa 'id' ao invés de 'sub' | |
| if "sub" not in known and "id" in data: | |
| known["sub"] = str(data["id"]) | |
| unknown.pop("id", None) | |
| # GitHub usa 'login' ao invés de 'preferred_username' | |
| if "preferred_username" not in known and "login" in data: | |
| known["preferred_username"] = data["login"] | |
| unknown.pop("login", None) | |
| # Se ainda não tem 'sub', usar email ou login como fallback | |
| if "sub" not in known: | |
| known["sub"] = known.get("email") or known.get("preferred_username") or "unknown" | |
| return cls( | |
| sub=known["sub"], | |
| name=known.get("name"), | |
| given_name=known.get("given_name"), | |
| family_name=known.get("family_name"), | |
| email=known.get("email"), | |
| email_verified=known.get("email_verified"), | |
| preferred_username=known.get("preferred_username"), | |
| claims=unknown, | |
| ) | |
| class JWK: | |
| """JSON Web Key.""" | |
| kty: str # Key type | |
| use: str | None = None # Public key use | |
| kid: str | None = None # Key ID | |
| alg: str | None = None # Algorithm | |
| n: str | None = None # RSA modulus | |
| e: str | None = None # RSA exponent | |
| x: str | None = None # Elliptic curve X coordinate | |
| y: str | None = None # Elliptic curve Y coordinate | |
| crv: str | None = None # Elliptic curve | |
| def from_dict(cls, data: dict[str, Any]) -> "JWK": | |
| """Create JWK from dictionary.""" | |
| return cls( | |
| kty=data["kty"], | |
| use=data.get("use"), | |
| kid=data.get("kid"), | |
| alg=data.get("alg"), | |
| n=data.get("n"), | |
| e=data.get("e"), | |
| x=data.get("x"), | |
| y=data.get("y"), | |
| crv=data.get("crv"), | |
| ) | |
| class JWKSet: | |
| """JSON Web Key Set.""" | |
| keys: list[JWK] | |
| def from_dict(cls, data: dict[str, Any]) -> "JWKSet": | |
| """Create JWKSet from JWKS endpoint response.""" | |
| return cls(keys=[JWK.from_dict(k) for k in data.get("keys", [])]) | |
| def get_key(self, kid: str) -> JWK | None: | |
| """Get key by ID.""" | |
| for key in self.keys: | |
| if key.kid == kid: | |
| return key | |
| return None | |
Xet Storage Details
- Size:
- 6.08 kB
- Xet hash:
- 2366bd9606025b43ea38166d4ae353afed47688a8858f21416870775ce455852
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.