code stringlengths 110 64.5k | apis list | extract_api stringlengths 123 69.9k |
|---|---|---|
from datetime import datetime
from typing import Optional
from fastapi import APIRouter
from sqlmodel import Field, SQLModel
router = APIRouter()
class Right(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
class Province(SQLModel, table=True):
id: Optional[in... | [
"sqlmodel.Field"
] | [((136, 147), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (145, 147), False, 'from fastapi import APIRouter\n'), ((209, 246), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (214, 246), False, 'from sqlmodel import Field, SQLModel\n'), ((325, ... |
from typing import Optional
from sqlmodel import Field, SQLModel, create_engine
class Team(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
headquarters: str
class Hero(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
nam... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.create_engine",
"sqlmodel.Field"
] | [((541, 577), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (554, 577), False, 'from sqlmodel import Field, SQLModel, create_engine\n'), ((141, 178), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key... |
"""initial2
Revision ID: 9d9a<PASSWORD>dbfd7
Revises: <PASSWORD>
Create Date: 2021-11-01 04:28:38.426261
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = '9d9a746db<PASSWORD>'
down_revision = 'a<PASSWORD>'
branch_labels = None
depends_on = None
... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((994, 1017), 'alembic.op.drop_table', 'op.drop_table', (['"""images"""'], {}), "('images')\n", (1007, 1017), False, 'from alembic import op\n'), ((561, 590), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""id"""'], {}), "('id')\n", (584, 590), True, 'import sqlalchemy as sa\n'), ((617, 637), 'alem... |
# Copyright 2021 Modelyst LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to... | [
"sqlmodel.Field"
] | [((1965, 2523), 'sqlmodel.Field', 'Field', (['default'], {'default_factory': 'default_factory', 'alias': 'alias', 'title': 'title', 'description': 'description', 'exclude': 'exclude', 'include': 'include', 'const': 'const', 'gt': 'gt', 'ge': 'ge', 'lt': 'lt', 'le': 'le', 'multiple_of': 'multiple_of', 'min_items': 'min_... |
import numpy as nm
import six
from sfepy import data_dir
from sfepy.base.base import Struct, output
from sfepy.terms.terms_hyperelastic_ul import HyperElasticULFamilyData
from sfepy.homogenization.micmac import get_homog_coefs_nonlinear
import sfepy.linalg as la
hyperelastic_data = {}
def post_process(out, pb, stat... | [
"sfepy.base.base.Struct",
"sfepy.linalg.rotation_matrix2d",
"sfepy.homogenization.micmac.get_homog_coefs_nonlinear",
"sfepy.linalg.dot_sequences",
"sfepy.base.base.output",
"sfepy.terms.terms_hyperelastic_ul.HyperElasticULFamilyData"
] | [((5887, 5921), 'numpy.array', 'nm.array', (['[0, 0]'], {'dtype': 'nm.float64'}), '([0, 0], dtype=nm.float64)\n', (5895, 5921), True, 'import numpy as nm\n'), ((2515, 2538), 'sfepy.base.base.output', 'output', (['"""get_homog_mat"""'], {}), "('get_homog_mat')\n", (2521, 2538), False, 'from sfepy.base.base import Struct... |
import uuid
from logging import getLogger
from typing import Optional
from fastapi import UploadFile
from sqlmodel import select, Session
from .models import User
logger = getLogger("uvicorn.error")
def get_user(username: str, session: Session) -> Optional[User]:
statement = select(User).where(User.username ==... | [
"sqlmodel.select"
] | [((175, 201), 'logging.getLogger', 'getLogger', (['"""uvicorn.error"""'], {}), "('uvicorn.error')\n", (184, 201), False, 'from logging import getLogger\n'), ((480, 492), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (490, 492), False, 'import uuid\n'), ((285, 297), 'sqlmodel.select', 'select', (['User'], {}), '(User)\n... |
from unittest.mock import patch
from sqlmodel import create_engine
from ...conftest import get_testing_print_function
def test_tutorial(clear_sqlmodel):
from docs_src.tutorial.where import tutorial010 as mod
mod.sqlite_url = "sqlite://"
mod.engine = create_engine(mod.sqlite_url)
calls = []
new... | [
"sqlmodel.create_engine"
] | [((267, 296), 'sqlmodel.create_engine', 'create_engine', (['mod.sqlite_url'], {}), '(mod.sqlite_url)\n', (280, 296), False, 'from sqlmodel import create_engine\n'), ((373, 411), 'unittest.mock.patch', 'patch', (['"""builtins.print"""'], {'new': 'new_print'}), "('builtins.print', new=new_print)\n", (378, 411), False, 'f... |
#!/usr/bin/env python
"""
Plot quadrature points for the given geometry and integration order.
"""
from optparse import OptionParser
import sfepy.postprocess.plot_quadrature as pq
usage = '%prog [options]\n' + __doc__.rstrip()
helps = {
'geometry' :
'reference element geometry, one of "2_3", "2_4", "3_4", "3... | [
"sfepy.postprocess.plot_quadrature.plt.show",
"sfepy.postprocess.plot_quadrature.plot_quadrature"
] | [((722, 764), 'optparse.OptionParser', 'OptionParser', ([], {'usage': 'usage', 'version': '"""%prog"""'}), "(usage=usage, version='%prog')\n", (734, 764), False, 'from optparse import OptionParser\n'), ((1782, 1907), 'sfepy.postprocess.plot_quadrature.plot_quadrature', 'pq.plot_quadrature', (['None', 'options.geometry'... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.core.tensor",
"megengine.test.assertTensorClose"
] | [((733, 756), 'megengine.test.assertTensorClose', 'assertTensorClose', (['a', 'b'], {}), '(a, b)\n', (750, 756), False, 'from megengine.test import assertTensorClose\n'), ((767, 782), 'tempfile.TemporaryFile', 'TemporaryFile', ([], {}), '()\n', (780, 782), False, 'from tempfile import TemporaryFile\n'), ((804, 848), 'n... |
import typing as t
from sqlmodel import SQLModel, Field, Relationship
from datetime import datetime
from .discussions import DB_Discussion
class DB_Post(SQLModel, table=True):
__tablename__ = 'posts'
id: t.Optional[int] = Field(default=None, primary_key=True)
"""The ID of the post. This is handled by t... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((235, 272), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (240, 272), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((362, 397), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""discussions.id"""'}), "(foreign_key='discussions... |
import megengine as mge
import megengine.functional as F
import numpy as np
def bilinear_sampler(img, coords, mode="bilinear", mask=False):
"""Wrapper for grid_sample, uses pixel coordinates"""
H, W = img.shape[-2:]
img = F.remap(img, coords, border_mode="constant")
if mask:
mask = (
... | [
"megengine.functional.remap",
"megengine.functional.stack",
"megengine.tensor",
"megengine.functional.expand_dims",
"megengine.functional.concat",
"megengine.functional.repeat",
"megengine.functional.logical_not"
] | [((237, 281), 'megengine.functional.remap', 'F.remap', (['img', 'coords'], {'border_mode': '"""constant"""'}), "(img, coords, border_mode='constant')\n", (244, 281), True, 'import megengine.functional as F\n'), ((805, 838), 'megengine.functional.stack', 'F.stack', (['[x_grid, y_grid]'], {'axis': '(0)'}), '([x_grid, y_g... |
# Copyright 2021 Modelyst LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to... | [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.text"
] | [((903, 919), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (917, 919), False, 'import pytest\n'), ((1232, 1262), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""module"""'}), "(scope='module')\n", (1246, 1262), False, 'import pytest\n'), ((1388, 1420), 'pytest.fixture', 'pytest.fixture', ([], {'scope': ... |
from unittest.mock import patch
from sqlmodel import create_engine
from ...conftest import get_testing_print_function
expected_calls = [
[
[
{
"id": 7,
"name": "Captain North America",
"secret_name": "<NAME>",
"age": 93,
... | [
"sqlmodel.create_engine"
] | [((502, 531), 'sqlmodel.create_engine', 'create_engine', (['mod.sqlite_url'], {}), '(mod.sqlite_url)\n', (515, 531), False, 'from sqlmodel import create_engine\n'), ((608, 646), 'unittest.mock.patch', 'patch', (['"""builtins.print"""'], {'new': 'new_print'}), "('builtins.print', new=new_print)\n", (613, 646), False, 'f... |
from time import sleep
from sqlmodel import select
from icon_governance.config import settings
from icon_governance.log import logger
from icon_governance.metrics import prom_metrics
from icon_governance.models.preps import Prep
from icon_governance.utils.rpc import convert_hex_int, getStake, post_rpc_json
def get_... | [
"sqlmodel.select"
] | [((370, 382), 'sqlmodel.select', 'select', (['Prep'], {}), '(Prep)\n', (376, 382), False, 'from sqlmodel import select\n'), ((645, 679), 'icon_governance.log.logger.info', 'logger.info', (['"""Starting stake cron"""'], {}), "('Starting stake cron')\n", (656, 679), False, 'from icon_governance.log import logger\n'), ((7... |
from typing import Optional
from sqlmodel import Field, SQLModel, Field
from pydantic import validator
from datetime import datetime, date
from fastapi import HTTPException
import re
class AppUser(SQLModel, table=True):
"""Create an SQLModel for users"""
id: Optional[int] = Field(default=None, primary_key=Tr... | [
"sqlmodel.Field"
] | [((286, 323), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (291, 323), False, 'from sqlmodel import Field, SQLModel, Field\n'), ((587, 623), 'pydantic.validator', 'validator', (['"""first_name"""'], {'always': '(True)'}), "('first_name', always=Tru... |
from select import select
from app.schemas.common import (
IGetResponseBase,
IPostResponseBase,
IDeleteResponseBase,
)
from app.utils.text_nlp import analyze_text
from app.schemas.text_inference import (
TextInferenceCreate,
TextInferenceRead,
)
from fastapi_pagination import Page, Params
from sqlmo... | [
"sqlmodel.select"
] | [((620, 631), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (629, 631), False, 'from fastapi import APIRouter, Depends, HTTPException, Query\n'), ((818, 827), 'fastapi.Depends', 'Depends', ([], {}), '()\n', (825, 827), False, 'from fastapi import APIRouter, Depends, HTTPException, Query\n'), ((860, 880), 'fastapi... |
import os
from fastapi import FastAPI
from sqlmodel import create_engine, SQLModel
from .configurations import env
from .models import * # init models package
class AppFactory(object):
def __init__(self):
self._app = None
@staticmethod
def _get_all_router():
from pigeon.blog.services.r... | [
"sqlmodel.SQLModel.metadata.create_all"
] | [((1026, 1054), 'fastapi.FastAPI', 'FastAPI', ([], {'title': '"""Pigeon Blog"""'}), "(title='Pigeon Blog')\n", (1033, 1054), False, 'from fastapi import FastAPI\n'), ((841, 877), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (869, 877), False, 'from sqlmodel im... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
from typing import Callable, Union
import megengine as mge
import megengine.functional as F
import megengine.module as M
from .activations import activation
__all__ = ["conv2d", "norm2d", "pool2d", "gap2d", "linear", "SE", "DropPath"]
... | [
"megengine.module.AdaptiveAvgPool2d",
"megengine.module.Identity",
"megengine.module.Sigmoid",
"megengine.module.Linear",
"megengine.functional.dropout",
"megengine.functional.ones",
"megengine.module.Conv2d"
] | [((1058, 1133), 'megengine.module.Conv2d', 'M.Conv2d', (['w_in', 'w_out', 'k'], {'stride': 's', 'padding': 'p', 'dilation': 'd', 'groups': 'g', 'bias': 'b'}), '(w_in, w_out, k, stride=s, padding=p, dilation=d, groups=g, bias=b)\n', (1066, 1133), True, 'import megengine.module as M\n'), ((2780, 2806), 'megengine.module.... |
import uuid
from datetime import datetime
from typing import Optional
from sqlalchemy import Column
from sqlalchemy.dialects.postgresql import JSON
from sqlmodel import Field, Relationship
from api.db.models.base import BaseModel, BaseTable
class OutOfBandBase(BaseModel):
msg_type: str = Field(nullable=False)
... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((297, 318), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (302, 318), False, 'from sqlmodel import Field, Relationship\n'), ((505, 525), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (510, 525), False, 'from sqlmodel import Field, Relationship\n'), ((6... |
from typing import Optional
from sqlmodel import Field, Session, SQLModel, create_engine, select
class Hero(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
secret_name: str
age: Optional[int] = None
sqlite_file_name = "database.db"
sqlite_url = f"sqlite://... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.Field",
"sqlmodel.select",
"sqlmodel.create_engine"
] | [((351, 387), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (364, 387), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((158, 195), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=... |
"""Add schools
Revision ID: 423e059e8b64
Revises: 58d2280520b8
Create Date: 2022-02-12 07:44:42.189067+00:00
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
# revision identifiers, used by Alembic.
revision = "423e059e8b64"
down_revision = "58d2280520b8"
branch_labels = None
depends_on = None
de... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((710, 787), 'alembic.op.create_foreign_key', 'op.create_foreign_key', (['None', '"""applications"""', '"""schools"""', "['school_id']", "['id']"], {}), "(None, 'applications', 'schools', ['school_id'], ['id'])\n", (731, 787), False, 'from alembic import op\n'), ((912, 972), 'alembic.op.drop_constraint', 'op.drop_cons... |
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY ... | [
"megengine.Tensor",
"megengine.functional.sqrt"
] | [((5519, 5532), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (5530, 5532), False, 'from collections import OrderedDict\n'), ((18529, 18542), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (18540, 18542), False, 'from collections import OrderedDict\n'), ((8433, 8532), 'numpy.array', 'np.array... |
"""Initial model generation
Revision ID: a2ced875a244
Revises:
Create Date: 2021-10-28 09:24:53.225445
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = 'a2ced875a244'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((2554, 2575), 'alembic.op.drop_table', 'op.drop_table', (['"""user"""'], {}), "('user')\n", (2567, 2575), False, 'from alembic import op\n'), ((2784, 2809), 'alembic.op.drop_table', 'op.drop_table', (['"""category"""'], {}), "('category')\n", (2797, 2809), False, 'from alembic import op\n'), ((626, 655), 'sqlalchemy.... |
import uuid
from datetime import datetime
from typing import Optional
from sqlalchemy import UniqueConstraint
from sqlmodel import Field, Relationship
from pydantic_factories import ModelFactory, Use
from faker import Faker
from api.db.models.base import BaseModel, BaseTable
class StudentBase(BaseModel):
name: s... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((325, 358), 'sqlmodel.Field', 'Field', ([], {'index': '(True)', 'nullable': '(False)'}), '(index=True, nullable=False)\n', (330, 358), False, 'from sqlmodel import Field, Relationship\n'), ((486, 520), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'nullable': '(True)'}), '(default=None, nullable=True)\n', (491,... |
from typing import Optional, List
from sqlalchemy import String
from sqlalchemy.sql.schema import Column
from sqlmodel import SQLModel, Field, Relationship
class CustomerProductLink(SQLModel, table=True):
customer_id: Optional[int] = Field(
default=None, foreign_key='customer.id', primary_key=True
)
... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((241, 305), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""customer.id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='customer.id', primary_key=True)\n", (246, 305), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((352, 415), 'sqlmodel.Field', 'Field', ([], {'def... |
r"""
Biot problem - deformable porous medium with the no-penetration boundary
condition on a boundary region enforced using Lagrange multipliers.
The non-penetration condition is enforced weakly using the Lagrange
multiplier :math:`\lambda`. There is also a rigid body movement
constraint imposed on the :math:`\Gamma_{... | [
"sfepy.base.base.Struct"
] | [((1657, 1732), 'sfepy.base.base.Struct', 'Struct', ([], {'name': '"""output_data"""', 'var_name': '"""p"""', 'mode': '"""cell"""', 'data': 'dvel', 'dofs': 'None'}), "(name='output_data', var_name='p', mode='cell', data=dvel, dofs=None)\n", (1663, 1732), False, 'from sfepy.base.base import Struct\n'), ((1889, 1966), 's... |
from sqlmodel import Session
from sfm.database import engine
from sfm.config import get_settings
from sfm.utils import verify_api_auth_token
from fastapi import Depends, HTTPException
from fastapi.security import HTTPBearer, HTTPBasicCredentials
from passlib.context import CryptContext
pwd_context = CryptContext(schem... | [
"sqlmodel.Session"
] | [((302, 353), 'passlib.context.CryptContext', 'CryptContext', ([], {'schemes': "['bcrypt']", 'deprecated': '"""auto"""'}), "(schemes=['bcrypt'], deprecated='auto')\n", (314, 353), False, 'from passlib.context import CryptContext\n'), ((369, 383), 'sfm.config.get_settings', 'get_settings', ([], {}), '()\n', (381, 383), ... |
import os
from dotenv import load_dotenv
from dateutil.parser import parse
from sqlmodel import Session, select, SQLModel, create_engine
import requests
from youtube.models import YouTube
load_dotenv()
YT_CHANNEL = os.environ["YT_CHANNEL"]
YOUTUBE_API_KEY = os.environ["YOUTUBE_API_KEY"]
DATABASE_URL = os.environ["D... | [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.select"
] | [((191, 204), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (202, 204), False, 'from dotenv import load_dotenv\n'), ((522, 561), 'sqlmodel.create_engine', 'create_engine', (['DATABASE_URL'], {'echo': '(False)'}), '(DATABASE_URL, echo=False)\n', (535, 561), False, 'from sqlmodel import Session, select, SQLModel... |
"""
The Dirichlet, periodic and linear combination boundary condition
classes, as well as the initial condition class.
"""
from __future__ import absolute_import
import numpy as nm
from sfepy.base.base import basestr, Container, Struct
from sfepy.discrete.functions import Function
import six
def get_condition_value(v... | [
"sfepy.base.base.Struct.__init__"
] | [((1475, 1494), 'six.iteritems', 'six.iteritems', (['conf'], {}), '(conf)\n', (1488, 1494), False, 'import six\n'), ((4772, 4814), 'sfepy.base.base.Struct.__init__', 'Struct.__init__', (['self'], {'name': 'name'}), '(self, name=name, **kwargs)\n', (4787, 4814), False, 'from sfepy.base.base import basestr, Container, St... |
r"""
Poisson equation.
This example demonstrates parametric study capabilities of Application
classes. In particular (written in the strong form):
.. math::
c \Delta t = f \mbox{ in } \Omega,
t = 2 \mbox{ on } \Gamma_1 \;,
t = -2 \mbox{ on } \Gamma_2 \;,
f = 1 \mbox{ in } \Omega_1 \;,
f = 0 \mbox... | [
"sfepy.base.base.output",
"sfepy.discrete.Problem.from_conf"
] | [((3347, 3371), 'numpy.sqrt', 'nm.sqrt', (['(x ** 2 + y ** 2)'], {}), '(x ** 2 + y ** 2)\n', (3354, 3371), True, 'import numpy as nm\n'), ((3381, 3403), 'numpy.where', 'nm.where', (['(r < diameter)'], {}), '(r < diameter)\n', (3389, 3403), True, 'import numpy as nm\n'), ((4097, 4121), 'numpy.linspace', 'nm.linspace', (... |
"""
Classes holding information on global DOFs and mapping of all DOFs -
equations (active DOFs).
Helper functions for the equation mapping.
"""
import numpy as nm
import scipy.sparse as sp
from sfepy.base.base import assert_, Struct, basestr
from sfepy.discrete.functions import Function
from sfepy.discrete.condition... | [
"sfepy.base.base.Struct",
"sfepy.discrete.conditions.get_condition_value",
"sfepy.base.base.Struct.__init__",
"sfepy.base.base.assert_"
] | [((570, 601), 'numpy.repeat', 'nm.repeat', (['nods', 'n_dof_per_node'], {}), '(nods, n_dof_per_node)\n', (579, 601), True, 'import numpy as nm\n'), ((663, 704), 'numpy.arange', 'nm.arange', (['n_dof_per_node'], {'dtype': 'nm.int32'}), '(n_dof_per_node, dtype=nm.int32)\n', (672, 704), True, 'import numpy as nm\n'), ((27... |
import typing as t
from sqlalchemy.orm import RelationshipProperty, selectinload
from sqlmodel import select
def get_schema_context(info):
schema_context = info.context["auto_schema"]
return schema_context
def get_model_for_type(info, type_):
schema_context = get_schema_context(info)
model = schema... | [
"sqlmodel.select"
] | [((3185, 3205), 'sqlalchemy.orm.selectinload', 'selectinload', (['column'], {}), '(column)\n', (3197, 3205), False, 'from sqlalchemy.orm import RelationshipProperty, selectinload\n'), ((7813, 7826), 'sqlmodel.select', 'select', (['model'], {}), '(model)\n', (7819, 7826), False, 'from sqlmodel import select\n'), ((6373,... |
"""
Functions for building queries, from nodes or SQL.
"""
import ast
import datetime
import operator
import re
from typing import Any, Callable, Dict, List, Literal, Optional, Set, Tuple, cast
from dateutil.parser import parse
from sqlalchemy.engine.url import make_url
from sqlalchemy.schema import Column as SqlaCol... | [
"sqlmodel.select"
] | [((1275, 1322), 're.compile', 're.compile', (['"""([\\\\w\\\\./_]+)(<=|<|>=|>|!=|=)(.+)"""'], {}), "('([\\\\w\\\\./_]+)(<=|<|>=|>|!=|=)(.+)')\n", (1285, 1322), False, 'import re\n'), ((2526, 2557), 'typing.cast', 'cast', (['FilterOperator', 'operator_'], {}), '(FilterOperator, operator_)\n', (2530, 2557), False, 'from ... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.utils.comp_graph_tools.load_and_inference",
"megengine.functional.arange",
"megengine.autodiff.GradManager",
"megengine.jit.trace",
"megengine.functional.clip",
"megengine.core.tensor.utils.isscalar",
"megengine.utils.comp_graph_tools.get_owner_opr_inputs",
"megengine.tensor",
"megengine.... | [((5110, 5174), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""force opt_level=0 when building graph"""'}), "(reason='force opt_level=0 when building graph')\n", (5126, 5174), False, 'import pytest\n'), ((5666, 5730), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""force opt_level=0 when buildi... |
import sys
sys.path.append('.')
import time
import megengine as mge
from model.RIFE import Model
model = Model()
model.eval()
I0 = mge.random(1, 3, 480, 640)
I1 = mge.random(1, 3, 480, 640)
for i in range(100):
pred = model.inference(I0, I1)
mge._full_sync()
time_stamp = time.time()
for i in range(100):
pred ... | [
"megengine.random",
"megengine._full_sync"
] | [((11, 31), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (26, 31), False, 'import sys\n'), ((106, 113), 'model.RIFE.Model', 'Model', ([], {}), '()\n', (111, 113), False, 'from model.RIFE import Model\n'), ((133, 159), 'megengine.random', 'mge.random', (['(1)', '(3)', '(480)', '(640)'], {}), '(1, ... |
"""
Classes of variables for equations/terms.
"""
from __future__ import print_function
from __future__ import absolute_import
from collections import deque
import numpy as nm
from sfepy.base.base import (real_types, complex_types, assert_, get_default,
output, OneTypeList, Container, Str... | [
"sfepy.discrete.conditions.get_condition_value",
"sfepy.discrete.common.dof_info.is_active_bc",
"sfepy.base.base.assert_",
"sfepy.discrete.common.dof_info.DofInfo",
"sfepy.discrete.integrals.Integral",
"sfepy.linalg.assemble1d",
"sfepy.discrete.evaluate_variable.eval_complex",
"sfepy.discrete.common.m... | [((1762, 1787), 'sfepy.base.base.get_default', 'get_default', (['var_indx', '{}'], {}), '(var_indx, {})\n', (1773, 1787), False, 'from sfepy.base.base import real_types, complex_types, assert_, get_default, output, OneTypeList, Container, Struct, basestr, iter_dict_of_lists\n'), ((3236, 3283), 'sfepy.base.base.iter_dic... |
"""empty message
Revision ID: de316f0831f9
Revises: 6<PASSWORD>1e462e9
Create Date: 2021-11-19 23:38:39.754126
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = "de316f0831f9"
down_revision = "60f151e462e9... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((461, 620), 'sqlalchemy.dialects.postgresql.ENUM', 'postgresql.ENUM', (['"""SALE_IN_PIX"""', '"""SALE_IN_DEBT"""', '"""SALE_IN_CREDIT"""', '"""SALE_IN_MONEY"""', '"""SALE_IN_TRANSFER"""', '"""SALE_IN_BILLET"""', '"""SALE_OTHERS"""'], {'name': '"""saletype"""'}), "('SALE_IN_PIX', 'SALE_IN_DEBT', 'SALE_IN_CREDIT',\n ... |
from __future__ import absolute_import
import numpy as nm
import numpy.linalg as nla
from sfepy.base.base import find_subclasses, assert_, Struct
from sfepy.linalg import combine, insert_strided_axis
from six.moves import range
from functools import reduce
# Requires fixed vertex numbering!
vertex_maps = {3 : [[0, 0,... | [
"sfepy.linalg.combine",
"sfepy.base.base.assert_",
"sfepy.linalg.insert_strided_axis"
] | [((859, 900), 'numpy.einsum', 'nm.einsum', (['"""cij,qdj->cqdi"""', 'transform', 'bf'], {}), "('cij,qdj->cqdi', transform, bf)\n", (868, 900), True, 'import numpy as nm\n'), ((926, 968), 'numpy.einsum', 'nm.einsum', (['"""cij,oqdj->cqdi"""', 'transform', 'bf'], {}), "('cij,oqdj->cqdi', transform, bf)\n", (935, 968), Tr... |
from __future__ import absolute_import
import numpy as nm
import sfepy.linalg as la
from sfepy.discrete.integrals import Integral
from sfepy.discrete import PolySpace
from six.moves import range
def prepare_remap(indices, n_full):
"""
Prepare vector for remapping range `[0, n_full]` to its subset given
by... | [
"sfepy.discrete.integrals.Integral",
"sfepy.linalg.normalize_vectors",
"sfepy.discrete.PolySpace.any_from_args",
"sfepy.linalg.norm_l2_along_axis",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.fem.FEDomain",
"sfepy.base.base.output"
] | [((352, 387), 'numpy.empty', 'nm.empty', (['(n_full,)'], {'dtype': 'nm.int32'}), '((n_full,), dtype=nm.int32)\n', (360, 387), True, 'import numpy as nm\n'), ((428, 471), 'numpy.arange', 'nm.arange', (['indices.shape[0]'], {'dtype': 'nm.int32'}), '(indices.shape[0], dtype=nm.int32)\n', (437, 471), True, 'import numpy as... |
"""
dayong.operations
~~~~~~~~~~~~~~~~~
Data model operations which include retrieval and update commands.
"""
from typing import Any
import tanjun
from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
from sqlmodel import SQLModel, select
from sqlmodel.engine.result import ScalarResult
from sqlmodel.ex... | [
"sqlmodel.ext.asyncio.session.AsyncSession",
"sqlmodel.select"
] | [((1190, 1224), 'tanjun.injected', 'tanjun.injected', ([], {'type': 'DayongConfig'}), '(type=DayongConfig)\n', (1205, 1224), False, 'import tanjun\n'), ((1650, 1674), 'sqlmodel.ext.asyncio.session.AsyncSession', 'AsyncSession', (['self._conn'], {}), '(self._conn)\n', (1662, 1674), False, 'from sqlmodel.ext.asyncio.sess... |
from typing import TYPE_CHECKING, List, Optional
from uuid import UUID
from sqlalchemy import event
from sqlalchemy.ext.orderinglist import ordering_list
from sqlalchemy.schema import Column, ForeignKey, UniqueConstraint
from sqlmodel import Field, Relationship
from sqlmodel.sql.sqltypes import GUID
from joj.horse.mo... | [
"sqlmodel.Relationship"
] | [((3592, 3647), 'sqlalchemy.event.listen', 'event.listen', (['ProblemSet', '"""before_insert"""', 'url_pre_save'], {}), "(ProblemSet, 'before_insert', url_pre_save)\n", (3604, 3647), False, 'from sqlalchemy import event\n'), ((3648, 3703), 'sqlalchemy.event.listen', 'event.listen', (['ProblemSet', '"""before_update"""'... |
"""Criação dos bancos de dados"""
from sqlmodel import SQLModel
from mitmirror.infra.entities import *
from .database_config import engine
def create_db():
"""Criando bancos de dados"""
base = SQLModel.metadata.create_all(engine)
return base
| [
"sqlmodel.SQLModel.metadata.create_all"
] | [((204, 240), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (232, 240), False, 'from sqlmodel import SQLModel\n')] |
#!/usr/bin/env python
# -*-coding=utf-8-*-
from megengine.logger import get_logger
logger = get_logger(__name__)
try:
from tensorboardX import SummaryWriter
from tensorboardX.proto.attr_value_pb2 import AttrValue
from tensorboardX.proto.graph_pb2 import GraphDef
from tensorboardX.proto.node_def_pb2 i... | [
"megengine.logger.get_logger"
] | [((94, 114), 'megengine.logger.get_logger', 'get_logger', (['__name__'], {}), '(__name__)\n', (104, 114), False, 'from megengine.logger import get_logger\n'), ((3050, 3090), 'tensorboardX.proto.summary_pb2.SummaryMetadata', 'SummaryMetadata', ([], {'plugin_data': 'plugin_data'}), '(plugin_data=plugin_data)\n', (3065, 3... |
from sqlite3.dbapi2 import Timestamp, adapt
from typing import Optional
from sqlmodel import Field, SQLModel
from pydantic import validator
from datetime import datetime, date
class Rate(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
user_id: int = Field(foreign_key="user.id"... | [
"sqlmodel.Field"
] | [((236, 273), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (241, 273), False, 'from sqlmodel import Field, SQLModel\n'), ((293, 321), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""user.id"""'}), "(foreign_key='user.id')\n", (298, 321), False,... |
# -*- coding: utf-8 -*-
from typing import List
from database import engine
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from models import Device, Project, Task, TaskWithProject
from sqlmodel import Session, SQLModel, select
# init fastapi
app: FastAPI = FastAPI()
# init CORS
app.... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.select"
] | [((293, 302), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (300, 302), False, 'from fastapi import FastAPI\n'), ((430, 455), 'fastapi.FastAPI', 'FastAPI', ([], {'title': '"""Scitizen"""'}), "(title='Scitizen')\n", (437, 455), False, 'from fastapi import FastAPI\n'), ((627, 663), 'sqlmodel.SQLModel.metadata.create_al... |
#! /usr/bin/env python3
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.utils.module_stats.sum_op_stats",
"megengine.logger.get_logger",
"megengine.utils.module_stats.print_param_stats",
"megengine.utils.module_stats.sum_param_stats",
"megengine.utils.module_stats.get_param_stats",
"megengine.utils.module_stats.print_op_stats",
"megengine.utils.network.Network.lo... | [((1019, 1039), 'megengine.logger.get_logger', 'get_logger', (['__name__'], {}), '(__name__)\n', (1029, 1039), False, 'from megengine.logger import _imperative_rt_logger, get_logger, set_mgb_log_level\n'), ((3458, 3482), 'megengine.utils.module_stats.enable_receptive_field', 'enable_receptive_field', ([], {}), '()\n', ... |
"""
Global interpolation functions.
"""
import time
import numpy as nm
from sfepy.base.base import output, get_default_attr
from sfepy.discrete.fem.mesh import make_inverse_connectivity
from sfepy.discrete.fem.extmods.bases import find_ref_coors
def get_ref_coors(field, coors, strategy='kdtree', close_limit=0.1, cach... | [
"sfepy.base.base.output",
"sfepy.discrete.fem.extmods.bases.find_ref_coors",
"sfepy.base.base.get_default_attr",
"sfepy.discrete.fem.mesh.make_inverse_connectivity"
] | [((1856, 1898), 'sfepy.base.base.get_default_attr', 'get_default_attr', (['cache', '"""ref_coors"""', 'None'], {}), "(cache, 'ref_coors', None)\n", (1872, 1898), False, 'from sfepy.base.base import output, get_default_attr\n'), ((1940, 1977), 'sfepy.base.base.get_default_attr', 'get_default_attr', (['cache', '"""mesh""... |
from http import HTTPStatus
from typing import List
from fastapi import APIRouter, Depends, Query, Response
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.future import select
from sqlmodel import func, select
from icon_governance.db import get_session
from icon_governance.models.delegations import D... | [
"sqlmodel.func.count",
"sqlmodel.select"
] | [((340, 351), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (349, 351), False, 'from fastapi import APIRouter, Depends, Query, Response\n'), ((488, 496), 'fastapi.Query', 'Query', (['(0)'], {}), '(0)\n', (493, 496), False, 'from fastapi import APIRouter, Depends, Query, Response\n'), ((515, 539), 'fastapi.Query',... |
#!/usr/bin/env python
"""
Plot quadrature points for the given geometry and integration order.
"""
from __future__ import absolute_import, print_function
import sys
sys.path.append('.')
from argparse import ArgumentParser
import sfepy.postprocess.plot_quadrature as pq
helps = {
'geometry' :
'reference element... | [
"sfepy.postprocess.plot_quadrature.plt.show",
"sfepy.postprocess.plot_quadrature.plot_quadrature"
] | [((165, 185), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (180, 185), False, 'import sys\n'), ((943, 978), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '__doc__'}), '(description=__doc__)\n', (957, 978), False, 'from argparse import ArgumentParser\n'), ((2550, 2775), 'sfepy.... |
import megengine as mge
import megengine.module as M
import pytest
from basecls.models.snet import SNV2Block, SNV2XceptionBlock
@pytest.mark.parametrize("w_in", [32, 48])
@pytest.mark.parametrize("w_out", [64])
@pytest.mark.parametrize("w_mid", [32, 24])
@pytest.mark.parametrize("stride", [1, 2])
@pytest.mark.parame... | [
"megengine.random.normal"
] | [((132, 173), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[32, 48]'], {}), "('w_in', [32, 48])\n", (155, 173), False, 'import pytest\n'), ((175, 213), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_out"""', '[64]'], {}), "('w_out', [64])\n", (198, 213), False, 'import pytest\n'... |
"""Implementing balance and fiscal_note_items tables
Revision ID: 6099ed2a58e0
Revises: <KEY>
Create Date: 2021-10-11 14:52:44.126077
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = "6099ed2a58e0"
down_r... | [
"sqlmodel.sql.sqltypes.AutoString",
"sqlmodel.sql.sqltypes.GUID"
] | [((5828, 5862), 'alembic.op.drop_table', 'op.drop_table', (['"""fiscal_note_items"""'], {}), "('fiscal_note_items')\n", (5841, 5862), False, 'from alembic import op\n'), ((6280, 6304), 'alembic.op.drop_table', 'op.drop_table', (['"""balance"""'], {}), "('balance')\n", (6293, 6304), False, 'from alembic import op\n'), (... |
# This example implements 2nd-level homogenization of Biot-Darcy-Brinkman model of flow in deformable
# double porous media.
# The mathematical model is described in:
#
#<NAME>., <NAME>., <NAME>.
#The Biot-Darcy-Brinkman model of flow in deformable double porous media; homogenization and numerical modelling.
# Co... | [
"sfepy.mechanics.tensors.dim2sym",
"sfepy.homogenization.utils.define_box_regions",
"sfepy.homogenization.micmac.get_homog_coefs_linear",
"sfepy.discrete.fem.mesh.Mesh.from_file"
] | [((2373, 2473), 'sfepy.homogenization.micmac.get_homog_coefs_linear', 'get_homog_coefs_linear', (['(0)', '(0)', 'None'], {'micro_filename': 'micro_filename', 'coefs_filename': 'coefs_filename'}), '(0, 0, None, micro_filename=micro_filename,\n coefs_filename=coefs_filename)\n', (2395, 2473), False, 'from sfepy.homoge... |
import os
import sys
import time
from collections import OrderedDict
from time import strftime, gmtime
from tensorboardX import SummaryWriter
from dataset import AsrDataset, DataLoader, AsrCollator
from models.transformer import Model
import hparams as hp
import argparse
import megengine as mge
import megengine.module ... | [
"megengine.core._imperative_rt.core2.push_scope",
"megengine.autodiff.GradManager",
"megengine.logger.get_logger",
"megengine.functional.minimum",
"megengine.random.uniform",
"megengine.distributed.init_process_group",
"megengine.distributed.make_allreduce_cb",
"megengine.functional.concat",
"megeng... | [((902, 931), 'megengine.logger.get_logger', 'megengine.logger.get_logger', ([], {}), '()\n', (929, 931), False, 'import megengine\n'), ((1050, 1078), 'megengine.core._imperative_rt.core2.push_scope', 'push_scope', (['"""clip_grad_norm"""'], {}), "('clip_grad_norm')\n", (1060, 1078), False, 'from megengine.core._impera... |
# -*- coding: utf-8
r"""
Homogenization of the Darcy flow in a thin porous layer.
The reference cell is composed of the matrix representing the dual porosity
and of two disconnected channels representing the primary porosity,
see paper [1].
[1] <NAME>, <NAME>: Modeling Tissue Perfusion Using a Homogenized
Model with L... | [
"sfepy.homogenization.recovery.compute_p_from_macro",
"sfepy.base.base.Struct"
] | [((5156, 5189), 'six.iteritems', 'six.iteritems', (["pb_def['channels']"], {}), "(pb_def['channels'])\n", (5169, 5189), False, 'import six\n'), ((6949, 6982), 'six.iteritems', 'six.iteritems', (["pb_def['channels']"], {}), "(pb_def['channels'])\n", (6962, 6982), False, 'import six\n'), ((10860, 10893), 'six.iteritems',... |
"""empty message
Revision ID: 2d614148ea4b
Revises:
Create Date: 2022-03-17 22:29:00.613962
"""
from alembic import op
import sqlalchemy as sa
import sqlalchemy_utils
import sqlmodel # added
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = '2d614148ea4b'
down_revision =... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((3708, 3742), 'alembic.op.drop_table', 'op.drop_table', (['"""zeroshotinference"""'], {}), "('zeroshotinference')\n", (3721, 3742), False, 'from alembic import op\n'), ((3824, 3854), 'alembic.op.drop_table', 'op.drop_table', (['"""textinference"""'], {}), "('textinference')\n", (3837, 3854), False, 'from alembic impo... |
"""
Computational domain for isogeometric analysis.
"""
import os.path as op
import numpy as nm
from sfepy.base.base import Struct
from sfepy.discrete.common.domain import Domain
import sfepy.discrete.iga as iga
import sfepy.discrete.iga.io as io
from sfepy.discrete.iga.extmods.igac import eval_in_tp_coors
class Nur... | [
"sfepy.discrete.iga.io.read_iga_data",
"sfepy.discrete.fem.Mesh.from_data",
"sfepy.base.base.Struct",
"sfepy.discrete.common.domain.Domain.__init__",
"sfepy.discrete.iga.get_bezier_element_entities",
"sfepy.discrete.fem.geometry_element.create_geometry_elements",
"sfepy.discrete.fem.extmods.cmesh.CMesh.... | [((472, 585), 'sfepy.base.base.Struct.__init__', 'Struct.__init__', (['self'], {'name': '"""nurbs"""', 'knots': 'knots', 'degrees': 'degrees', 'cps': 'cps', 'weights': 'weights', 'cs': 'cs', 'conn': 'conn'}), "(self, name='nurbs', knots=knots, degrees=degrees, cps=cps,\n weights=weights, cs=cs, conn=conn)\n", (487, ... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import megengine as mge
import megengine.module as M
import numpy as np
import pytest
import torch
import torch.nn as nn
from basecls.configs import BaseConfig
from basecls.layers import BinaryCrossEntropy, CrossEntropy, build_loss
@py... | [
"megengine.Tensor"
] | [((318, 407), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""name"""', "[CrossEntropy, 'BinaryCrossEntropy', 'CrossEntropy']"], {}), "('name', [CrossEntropy, 'BinaryCrossEntropy',\n 'CrossEntropy'])\n", (341, 407), False, 'import pytest\n'), ((483, 498), 'basecls.layers.build_loss', 'build_loss', (['cfg... |
#!/usr/bin/env python
from __future__ import print_function
from __future__ import absolute_import
from argparse import ArgumentParser
import numpy as nm
import sys
sys.path.append('.')
from sfepy.base.base import IndexedStruct
from sfepy.discrete import (FieldVariable, Material, Integral, Function,
... | [
"sfepy.discrete.conditions.EssentialBC",
"sfepy.discrete.Integral",
"sfepy.postprocess.viewer.Viewer",
"sfepy.solvers.ls.ScipyDirect",
"sfepy.discrete.Equations",
"sfepy.discrete.fem.Field.from_args",
"sfepy.discrete.Equation",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.fem.FEDomain",
"s... | [((166, 186), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (181, 186), False, 'import sys\n'), ((980, 996), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (994, 996), False, 'from argparse import ArgumentParser\n'), ((1275, 1333), 'sfepy.discrete.fem.Mesh.from_file', 'Mesh.from_fi... |
from typing import Optional
from sqlmodel import Field, SQLModel, create_engine
class Student(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
first_name: str
last_name: str
email: str
# dob:
sqlite_url = "sqlite:///school.db"
engine = create_engine(sqlite_url)
... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.create_engine"
] | [((294, 319), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {}), '(sqlite_url)\n', (307, 319), False, 'from sqlmodel import Field, SQLModel, create_engine\n'), ((320, 356), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (348, 356), False, 'from sql... |
from sqlmodel import Session, func, text, SQLModel, select
from typing import Any, List, Literal, Optional, Type, TypeVar, Generic
ReadType = TypeVar("ReadType", bound=SQLModel)
CreateType = TypeVar("CreateType", bound=SQLModel)
UpdateType = TypeVar("UpdateType", bound=SQLModel)
class BaseRepository(Generic[ReadType... | [
"sqlmodel.func.count",
"sqlmodel.text",
"sqlmodel.select"
] | [((143, 178), 'typing.TypeVar', 'TypeVar', (['"""ReadType"""'], {'bound': 'SQLModel'}), "('ReadType', bound=SQLModel)\n", (150, 178), False, 'from typing import Any, List, Literal, Optional, Type, TypeVar, Generic\n'), ((192, 229), 'typing.TypeVar', 'TypeVar', (['"""CreateType"""'], {'bound': 'SQLModel'}), "('CreateTyp... |
from sqlmodel import Session, select
from database import UserRead, PostCreate, UserCreate, User, Post
from typing import Union
from datetime import datetime
def create_object(
session: Session,
model: Union[User, Post],
request_data: Union[UserCreate, PostCreate],
user: UserRead = None,
isPost:... | [
"sqlmodel.select"
] | [((574, 591), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (589, 591), False, 'from datetime import datetime\n'), ((518, 535), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (533, 535), False, 'from datetime import datetime\n'), ((1628, 1645), 'datetime.datetime.utcnow', 'datetime.... |
import hypothesis.strategies as st
from hypothesis import given
from hypothesis.strategies import DataObject
from sqlmodel import Session, select
from fastapi_server.models.user import User
from fastapi_server.test.base_test import BaseTest
class TestDatabase(BaseTest):
def test_user_add_single(self, method_ses... | [
"sqlmodel.select"
] | [((599, 720), 'fastapi_server.models.user.User', 'User', ([], {'username': 'username', 'email': 'email', 'password_hashed': 'password', 'is_admin': '(False)', 'is_disabled': '(False)', 'is_verified': '(False)'}), '(username=username, email=email, password_hashed=password, is_admin=\n False, is_disabled=False, is_ver... |
import os
import asyncio
import subprocess
import contextlib
import contextvars
from typing import *
import wait4it
import sqlmodel
from sqlmodel import Session
from aioify import aioify
from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric
from twitterscraper.utils import Singleton
cla... | [
"sqlmodel.Session",
"sqlmodel.create_engine",
"sqlmodel.select"
] | [((545, 572), 'sqlmodel.create_engine', 'sqlmodel.create_engine', (['uri'], {}), '(uri)\n', (567, 572), False, 'import sqlmodel\n'), ((608, 655), 'contextvars.ContextVar', 'contextvars.ContextVar', (['"""session"""'], {'default': 'None'}), "('session', default=None)\n", (630, 655), False, 'import contextvars\n'), ((104... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.tensor",
"megengine.quantization.utils.tqt_forward",
"megengine.quantization.utils.fake_quant_tensor",
"megengine.core.tensor.utils.make_shape_tuple",
"megengine.core.autodiff.grad.Grad"
] | [((2219, 2254), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(1, 2, 3, 4)'}), '(size=(1, 2, 3, 4))\n', (2235, 2254), True, 'import numpy as np\n'), ((2295, 2339), 'numpy.ones', 'np.ones', ([], {'shape': '(1, 2, 3, 4)', 'dtype': '"""float32"""'}), "(shape=(1, 2, 3, 4), dtype='float32')\n", (2302, 2339), Tru... |
from datetime import datetime
from typing import Optional
from fastapi import APIRouter
from sqlmodel import Field, SQLModel
router = APIRouter()
class Disease(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
class DiseaseGroup(SQLModel, table=True):
id: Optio... | [
"sqlmodel.Field"
] | [((136, 147), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (145, 147), False, 'from fastapi import APIRouter\n'), ((211, 248), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (216, 248), False, 'from sqlmodel import Field, SQLModel\n'), ((331, ... |
import os
import pathlib
from datetime import datetime, date, time
from decimal import Decimal
from typing import Optional, List
from fastapi import APIRouter, Depends, HTTPException, status, File, UploadFile
from fastapi.encoders import jsonable_encoder
from sqlmodel import Field, SQLModel
from ..db import get_sessi... | [
"sqlmodel.Field"
] | [((412, 423), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (421, 423), False, 'from fastapi import APIRouter, Depends, HTTPException, status, File, UploadFile\n'), ((577, 614), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (582, 614), False, ... |
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY ... | [
"megengine.distributed.functional.remote_recv",
"megengine.functional.ones",
"megengine.module.Conv2d",
"megengine.distributed.get_rank",
"megengine.functional.batch_norm",
"megengine.distributed.get_world_size",
"megengine.Parameter",
"megengine.jit.trace",
"megengine.functional.matmul",
"megengi... | [((847, 863), 'megengine.tensor', 'mge.tensor', (['(-1.0)'], {}), '(-1.0)\n', (857, 863), True, 'import megengine as mge\n'), ((928, 942), 'megengine.functional.matmul', 'F.matmul', (['x', 'w'], {}), '(x, w)\n', (936, 942), True, 'import megengine.functional as F\n'), ((1396, 1416), 'megengine.Parameter', 'mge.Paramete... |
# Copyright (c) 2020 <NAME>
# This code is licensed under MIT license
# (https://github.com/kwotsin/mimicry/blob/master/LICENSE)
# ------------------------------------------------------------------------------
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megv... | [
"megengine.random.gaussian",
"megengine.functional.zero_grad",
"megengine.functional.sigmoid"
] | [((2259, 2298), 'megengine.random.gaussian', 'R.gaussian', ([], {'shape': '[batch_size, self.nz]'}), '(shape=[batch_size, self.nz])\n', (2269, 2298), True, 'import megengine.random as R\n'), ((3780, 3804), 'megengine.functional.zero_grad', 'F.zero_grad', (['fake_images'], {}), '(fake_images)\n', (3791, 3804), True, 'im... |
"""add application resume
Revision ID: 07061a7c250f
Revises: 378a9b9a491b
Create Date: 2022-04-26 08:00:47.428979+00:00
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
# revision identifiers, used by Alembic.
revision = "07061a7c250f"
down_revision = "378a9b9a491b"
branch_labels = None
depends_on ... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((496, 536), 'alembic.op.drop_column', 'op.drop_column', (['"""applications"""', '"""resume"""'], {}), "('applications', 'resume')\n", (510, 536), False, 'from alembic import op\n'), ((415, 449), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (447, 449), False, 'import sqlmod... |
from sqlalchemy import inspect
from sqlalchemy.engine.reflection import Inspector
from sqlmodel import create_engine
def test_tutorial001(clear_sqlmodel):
from docs_src.tutorial.connect.create_tables import tutorial001 as mod
mod.sqlite_url = "sqlite://"
mod.engine = create_engine(mod.sqlite_url)
mod... | [
"sqlmodel.create_engine"
] | [((283, 312), 'sqlmodel.create_engine', 'create_engine', (['mod.sqlite_url'], {}), '(mod.sqlite_url)\n', (296, 312), False, 'from sqlmodel import create_engine\n'), ((317, 327), 'docs_src.tutorial.connect.create_tables.tutorial001.main', 'mod.main', ([], {}), '()\n', (325, 327), True, 'from docs_src.tutorial.connect.cr... |
from typing import Optional
from sqlmodel import Field, SQLModel
from datetime import datetime, date
class Rate(SQLModel, table=True):
"""Create an SQLModel for rates"""
id: Optional[int] = Field(default=None, primary_key=True)
user_id: int = Field(foreign_key="app_db.appuser.id")
client_id: int = Fi... | [
"sqlmodel.Field"
] | [((201, 238), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (206, 238), False, 'from sqlmodel import Field, SQLModel\n'), ((258, 296), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""app_db.appuser.id"""'}), "(foreign_key='app_db.appuser.id')\n"... |
# -*- coding: utf-8 -*-
# Copyright 2018-2019 Open-MMLab.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable ... | [
"megengine.functional.linspace",
"megengine.core.tensor",
"megengine.functional.add_axis",
"megengine.functional.concat"
] | [((2161, 2180), 'numpy.array', 'np.array', (['[2, 3, 4]'], {}), '([2, 3, 4])\n', (2169, 2180), True, 'import numpy as np\n'), ((2218, 2239), 'numpy.array', 'np.array', (['[0.5, 1, 2]'], {}), '([0.5, 1, 2])\n', (2226, 2239), True, 'import numpy as np\n'), ((2971, 3025), 'megengine.core.tensor', 'tensor', (['[0, 0, self.... |
"""initial
Revision ID: ef<PASSWORD>
Revises:
Create Date: 2022-03-03 15:21:30.974400
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = "ef<PASSWORD>"
down_revision = None
branch_labels = None
depends_on =... | [
"sqlmodel.sql.sqltypes.GUID",
"sqlmodel.sql.sqltypes.AutoString"
] | [((7044, 7072), 'alembic.op.drop_table', 'op.drop_table', (['"""out_of_band"""'], {}), "('out_of_band')\n", (7057, 7072), False, 'from alembic import op\n'), ((7142, 7166), 'alembic.op.drop_table', 'op.drop_table', (['"""student"""'], {}), "('student')\n", (7155, 7166), False, 'from alembic import op\n'), ((7171, 7204)... |
from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel
from pydantic.networks import HttpUrl
from sqlmodel import Field, SQLModel
PageType = str
class Ecoindex(SQLModel):
grade: Optional[str] = Field(
default=None,
title="Ecoindex grade",
descripti... | [
"sqlmodel.Field"
] | [((242, 367), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'title': '"""Ecoindex grade"""', 'description': '"""Is the corresponding ecoindex grade of the page (from A to G)"""'}), "(default=None, title='Ecoindex grade', description=\n 'Is the corresponding ecoindex grade of the page (from A to G)')\n", (247, ... |
from typing import Optional, List
from sqlmodel import (
SQLModel,
Field,
create_engine,
Relationship
)
engine = create_engine('sqlite:///database.db')
class Person(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
nome: str
idade: int
livros: List['Li... | [
"sqlmodel.Relationship",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.create_engine",
"sqlmodel.Field"
] | [((131, 169), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite:///database.db"""'], {}), "('sqlite:///database.db')\n", (144, 169), False, 'from sqlmodel import SQLModel, Field, create_engine, Relationship\n'), ((629, 665), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {})... |
from __future__ import annotations
import inspect
from functools import wraps
from typing import Any, Callable, Dict, List, Literal, Type, TypeVar
from fastapi.encoders import jsonable_encoder
from sqlalchemy.orm import Query, noload, raiseload, selectinload, subqueryload
from sqlalchemy.sql.elements import BinaryExp... | [
"sqlmodel.select"
] | [((428, 457), 'typing.TypeVar', 'TypeVar', (['"""Self"""'], {'bound': '"""Base"""'}), "('Self', bound='Base')\n", (435, 457), False, 'from typing import Any, Callable, Dict, List, Literal, Type, TypeVar\n'), ((1277, 1288), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (1282, 1288), False, 'from functools impo... |
"""initial3
Revision ID: 01b6c8ce3965
Revises: <PASSWORD>
Create Date: 2021-11-01 04:29:57.210756
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = '01b6c8ce3965'
down_revision = '<PASSWORD>'
branch_labels = None
depends_on = None
def upgrade():... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((1075, 1108), 'alembic.op.drop_column', 'op.drop_column', (['"""listings"""', '"""url"""'], {}), "('listings', 'url')\n", (1089, 1108), False, 'from alembic import op\n'), ((1243, 1277), 'alembic.op.drop_column', 'op.drop_column', (['"""images"""', '"""size_y"""'], {}), "('images', 'size_y')\n", (1257, 1277), False, ... |
import megengine as mge
import megengine.module as nn
import megengine.functional as F
from model.module import Encoder, Fusion, Decoder, Regression
from common import se3, quaternion
import math
class OMNet(nn.Module):
def __init__(self, params):
super(OMNet, self).__init__()
self.num_iter = para... | [
"megengine.functional.repeat",
"megengine.module.init.calculate_fan_in_and_fan_out",
"megengine.functional.ones",
"megengine.functional.expand_dims",
"megengine.functional.concat",
"megengine.functional.max",
"megengine.functional.min",
"megengine.functional.argmax",
"megengine.tensor",
"megengine... | [((1424, 1467), 'common.se3.mge_transform', 'se3.mge_transform', (['transform_gt', 'points_src'], {}), '(transform_gt, points_src)\n', (1441, 1467), False, 'from common import se3, quaternion\n'), ((1489, 1522), 'megengine.functional.expand_dims', 'F.expand_dims', (['points_src'], {'axis': '(2)'}), '(points_src, axis=2... |
import os
from venv import create
from sqlmodel import SQLModel, create_engine
from .base_variables import APPNAME,DEBUG
from utils import print_warning
import sys
if DEBUG:
PG_HOST: str = os.getenv("PGHOST", "localhost")
PG_USER: str = os.getenv("PGUSER", "postgres")
PG_PASSWORD: str = os.getenv("PGPASSWOR... | [
"sqlmodel.create_engine"
] | [((847, 874), 'sqlmodel.create_engine', 'create_engine', (['DATABASE_URL'], {}), '(DATABASE_URL)\n', (860, 874), False, 'from sqlmodel import SQLModel, create_engine\n'), ((193, 225), 'os.getenv', 'os.getenv', (['"""PGHOST"""', '"""localhost"""'], {}), "('PGHOST', 'localhost')\n", (202, 225), False, 'import os\n'), ((2... |
import os
import time
import numpy as np
import megengine.distributed as dist
import megengine as mge
import megengine.functional as F
from megengine.autodiff import GradManager
from edit.core.hook.evaluation import psnr, ssim
from edit.utils import imwrite, tensor2img, bgr2ycbcr, img_multi_padding, img_de_multi_paddin... | [
"megengine.tensor",
"megengine.functional.nn.interpolate",
"megengine.distributed.functional.all_reduce_sum",
"megengine.functional.zeros",
"megengine.functional.stack",
"megengine.functional.expand_dims",
"megengine.distributed.is_distributed",
"megengine.distributed.get_world_size",
"megengine.fun... | [((2104, 2148), 'megengine.functional.zeros', 'F.zeros', (['(2 * B, netG.hidden_channels, h, w)'], {}), '((2 * B, netG.hidden_channels, h, w))\n', (2111, 2148), True, 'import megengine.functional as F\n'), ((2722, 2742), 'megengine.functional.stack', 'F.stack', (['res'], {'axis': '(1)'}), '(res, axis=1)\n', (2729, 2742... |
from sqlmodel import create_engine
from pyflarum.database.session import FlarumDatabase
from pyflarum.database.flarum.core.users import DB_User
ENGINE = create_engine('sqlite:///tests/database/database.db')
DATABASE = FlarumDatabase(engine=ENGINE)
if __name__ == "__main__":
with DATABASE:
for user in ... | [
"sqlmodel.create_engine"
] | [((156, 209), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite:///tests/database/database.db"""'], {}), "('sqlite:///tests/database/database.db')\n", (169, 209), False, 'from sqlmodel import create_engine\n'), ((221, 250), 'pyflarum.database.session.FlarumDatabase', 'FlarumDatabase', ([], {'engine': 'ENGINE'}), ... |
"""
dayong.impls
~~~~~~~~~~~~
Implementaion of interfaces and the logic for injecting them.
"""
import asyncio
from typing import Any
import tanjun
from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
from sqlmodel import SQLModel, select
from sqlmodel.engine.result import ScalarResult
from sqlmodel.ex... | [
"sqlmodel.ext.asyncio.session.AsyncSession",
"sqlmodel.select"
] | [((917, 951), 'tanjun.injected', 'tanjun.injected', ([], {'type': 'DayongConfig'}), '(type=DayongConfig)\n', (932, 951), False, 'import tanjun\n'), ((1285, 1311), 'asyncio.get_running_loop', 'asyncio.get_running_loop', ([], {}), '()\n', (1309, 1311), False, 'import asyncio\n'), ((2066, 2090), 'sqlmodel.ext.asyncio.sess... |
from sqlalchemy.engine import Engine
from sqlmodel import create_engine, Session, SQLModel
from sqlmodel.engine.create import _FutureEngine
from typing import Union, Optional
from pyemits.common.validation import raise_if_incorrect_type, raise_if_not_all_value_contains, \
raise_if_not_all_element_type_uniform, chec... | [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all"
] | [((2815, 2859), 'pyemits.common.validation.check_all_element_type_uniform', 'check_all_element_type_uniform', (['tables', 'list'], {}), '(tables, list)\n', (2845, 2859), False, 'from pyemits.common.validation import raise_if_incorrect_type, raise_if_not_all_value_contains, raise_if_not_all_element_type_uniform, check_a... |
from collections import deque
from time import sleep
import pytest
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.common.exceptions import WebDriverException
from sqlmodel import Session, select
from youtube.db import engine
from youtube.models import YouTube
@pytest.fi... | [
"sqlmodel.Session",
"sqlmodel.select"
] | [((311, 342), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (325, 342), False, 'import pytest\n'), ((616, 647), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (630, 647), False, 'import pytest\n'), ((370, 388), 'selenium.webdri... |
import logging
from datetime import datetime
from typing import List
from sqlmodel import Session, select
from db import engine
from models import Social, User
def get_last_social() -> Social:
with Session(engine) as session:
statement = select(Social).order_by(Social.id.desc()).limit(1)
result ... | [
"sqlmodel.select",
"sqlmodel.Session"
] | [((364, 408), 'logging.info', 'logging.info', (['f"""SELECT social row: {result}"""'], {}), "(f'SELECT social row: {result}')\n", (376, 408), False, 'import logging\n'), ((643, 696), 'logging.info', 'logging.info', (['f"""SELECT previous social row: {result}"""'], {}), "(f'SELECT previous social row: {result}')\n", (65... |
input_names = {'TL': '../examples/large_deformation/hyperelastic.py',
'UL': '../examples/large_deformation/hyperelastic_ul.py',
'ULM': '../examples/large_deformation/hyperelastic_ul_up.py'}
output_name_trunk = 'test_hyperelastic_'
from sfepy.base.testing import TestCommon
from tests_basic... | [
"sfepy.base.conf.get_standard_keywords",
"sfepy.base.base.Struct",
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.applications.solve_pde",
"sfepy.applications.assign_standard_hooks"
] | [((871, 894), 'sfepy.base.conf.get_standard_keywords', 'get_standard_keywords', ([], {}), '()\n', (892, 894), False, 'from sfepy.base.conf import ProblemConf, get_standard_keywords\n'), ((987, 1037), 'sfepy.base.conf.ProblemConf.from_file', 'ProblemConf.from_file', (['input_name', 'required', 'other'], {}), '(input_nam... |
from typing import Optional
from uuid import UUID
from ecoindex.models import Result
from sqlmodel import Field
class ApiEcoindex(Result, table=True):
id: Optional[UUID] = Field(
default=None, description="Analysis ID of type `UUID`", primary_key=True
)
host: str = Field(
default=..., tit... | [
"sqlmodel.Field"
] | [((179, 258), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'description': '"""Analysis ID of type `UUID`"""', 'primary_key': '(True)'}), "(default=None, description='Analysis ID of type `UUID`', primary_key=True)\n", (184, 258), False, 'from sqlmodel import Field\n'), ((289, 376), 'sqlmodel.Field', 'Field', ([],... |
"""add swag tiers
Revision ID: <KEY>
Revises: 02338256c6aa
Create Date: 2022-06-01 05:58:25.373228+00:00
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
# revision identifiers, used by Alembic.
revision = "<KEY>"
down_revision = "02338256c6aa"
branch_labels = None
depends_on = None
def upgrade()... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((876, 963), 'alembic.op.create_foreign_key', 'op.create_foreign_key', (['None', '"""participants"""', '"""swag_tiers"""', "['swag_tier_id']", "['id']"], {}), "(None, 'participants', 'swag_tiers', ['swag_tier_id'],\n ['id'])\n", (897, 963), False, 'from alembic import op\n'), ((1084, 1144), 'alembic.op.drop_constra... |
r"""
Compute homogenized elastic coefficients for a given heterogeneous linear
elastic microstructure, see [1] for details or [2] and [3] for a quick
explanation.
[1] <NAME>, <NAME>: Homogenization in open sets with holes.
Journal of Mathematical Analysis and Applications 71(2), 1979, pages 590-607.
https://doi.org/... | [
"sfepy.base.base.Struct",
"sfepy.homogenization.recovery.compute_micro_u",
"sfepy.homogenization.utils.define_box_regions",
"sfepy.homogenization.recovery.compute_mac_stress_part",
"sfepy.homogenization.recovery.compute_stress_strain_u",
"sfepy.mechanics.matcoefs.stiffness_from_youngpoisson"
] | [((1476, 1554), 'sfepy.base.base.Struct', 'Struct', ([], {'name': '"""output_data"""', 'mode': '"""vertex"""', 'data': 'mic_u', 'var_name': '"""u"""', 'dofs': 'None'}), "(name='output_data', mode='vertex', data=mic_u, var_name='u', dofs=None)\n", (1482, 1554), False, 'from sfepy.base.base import Struct\n'), ((1643, 170... |
from __future__ import absolute_import
import numpy as nm
from sfepy.base.base import output, iter_dict_of_lists, Struct, basestr
from sfepy.base.timing import Timer
import six
def parse_approx_order(approx_order):
"""
Parse the uniform approximation order value (str or int).
"""
ao_msg = 'unsupport... | [
"sfepy.get_paths",
"sfepy.base.base.Struct",
"sfepy.discrete.common.global_interp.get_ref_coors",
"sfepy.base.multiproc.is_remote_dict",
"sfepy.base.timing.Timer",
"sfepy.base.base.iter_dict_of_lists",
"sfepy.base.base.load_classes",
"sfepy.base.base.output"
] | [((1640, 1687), 'sfepy.base.base.iter_dict_of_lists', 'iter_dict_of_lists', (['conn_info'], {'return_keys': '(True)'}), '(conn_info, return_keys=True)\n', (1658, 1687), False, 'from sfepy.base.base import output, iter_dict_of_lists, Struct, basestr\n'), ((1941, 1960), 'six.iteritems', 'six.iteritems', (['conf'], {}), '... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import copy
import time
from typing import Iterable
import megengine as mge
import megengine.amp as amp
import megengine.distributed as dist
import megengine.functional as F
import megengine.module as M
import megengine.optimizer as opti... | [
"megengine.jit.trace",
"megengine.distributed.get_world_size",
"megengine.optimizer.clip_grad_value",
"megengine.amp.autocast",
"megengine.optimizer.clip_grad_norm",
"megengine.functional.argmax",
"megengine._full_sync",
"megengine.functional.metric.topk_accuracy"
] | [((666, 695), 'basecls.utils.registers.trainers.register', 'registers.trainers.register', ([], {}), '()\n', (693, 695), False, 'from basecls.utils import registers\n'), ((1698, 1757), 'basecls.layers.Preprocess', 'Preprocess', (['cfg.preprocess.img_mean', 'cfg.preprocess.img_std'], {}), '(cfg.preprocess.img_mean, cfg.p... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.core._imperative_rt.imperative.make_backward_graph",
"megengine.functional.distributed.remote_send",
"megengine.functional.expand_dims",
"megengine.functional.distributed.remote_recv",
"megengine.core._imperative_rt.imperative.sync",
"megengine.distributed.init_process_group",
"megengine.func... | [((3488, 3558), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""high order gradient was not implemented yet"""'}), "(reason='high order gradient was not implemented yet')\n", (3504, 3558), False, 'import pytest\n'), ((1041, 1055), 'megengine.core.ops.builtin.Elemwise', 'Elemwise', (['mode'], {}), '(mode)\n'... |
from fastapi import APIRouter, Depends
from ..utils import engine, get_session
from sqlmodel import Session, select, SQLModel, or_
from sqlalchemy.exc import NoResultFound
from ..models.role import Role
from datetime import datetime
router = APIRouter(prefix="/api/roles", tags=["role"])
session = Session(engine)
# Po... | [
"sqlmodel.Session",
"sqlmodel.select"
] | [((243, 288), 'fastapi.APIRouter', 'APIRouter', ([], {'prefix': '"""/api/roles"""', 'tags': "['role']"}), "(prefix='/api/roles', tags=['role'])\n", (252, 288), False, 'from fastapi import APIRouter, Depends\n'), ((299, 314), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (306, 314), False, 'from sqlmode... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.tensor"
] | [((2620, 2668), 'numpy.array', 'np.array', (['[[100, 101, 102, 103]]'], {'dtype': 'np.int32'}), '([[100, 101, 102, 103]], dtype=np.int32)\n', (2628, 2668), True, 'import numpy as np\n'), ((2680, 2705), 'numpy.repeat', 'np.repeat', (['tmp', '(4)'], {'axis': '(0)'}), '(tmp, 4, axis=0)\n', (2689, 2705), True, 'import nump... |
from sqlmodel import SQLModel
from sqlmodel import Field, Relationship
from sqlalchemy import String
from sqlalchemy.sql.schema import Column
from typing import TYPE_CHECKING, Optional, List
if TYPE_CHECKING:
from app.src.models.product import ProductRead
from app.src.models.product import Product
class Prod... | [
"sqlmodel.Field",
"sqlmodel.Relationship"
] | [((452, 489), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (457, 489), False, 'from sqlmodel import Field, Relationship\n'), ((592, 611), 'sqlmodel.Field', 'Field', ([], {'default': 'None'}), '(default=None)\n', (597, 611), False, 'from sqlmodel im... |
"""All Models for database are defined here"""
from typing import Optional, List
from sqlalchemy import Column, ForeignKey, Integer
from sqlmodel import Field, SQLModel, Relationship
class VrfLink(SQLModel, table=True):
"""Used for vrf to device link"""
vrf_id: Optional[int] = Field(default=None, foreign_key=... | [
"sqlmodel.Field",
"sqlmodel.Relationship"
] | [((288, 347), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""vrf.id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='vrf.id', primary_key=True)\n", (293, 347), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((379, 441), 'sqlmodel.Field', 'Field', ([], {'default': 'No... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.functional.div",
"megengine.functional.broadcast_to",
"megengine.jit.trace",
"megengine.functional.sub",
"megengine.functional.vision.warp_perspective",
"megengine.functional.concat",
"megengine.functional.transpose"
] | [((795, 827), 'megengine.jit.trace', 'jit.trace', ([], {'capture_as_const': '(True)'}), '(capture_as_const=True)\n', (804, 827), False, 'from megengine import jit\n'), ((1815, 1888), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""MegEngine Classification Dump .mge"""'}), "(description='M... |
from typing import Optional
import pytest
from sqlmodel import Field, SQLModel, create_engine
def test_missing_sql_type():
class CustomType:
@classmethod
def __get_validators__(cls):
yield cls.validate
@classmethod
def validate(cls, v):
return v
... | [
"sqlmodel.Field"
] | [((332, 357), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(ValueError)\n', (345, 357), False, 'import pytest\n'), ((433, 470), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (438, 470), False, 'from sqlmodel import Field, SQLModel, creat... |
import textwrap
from typing import List, Optional
import pytest
from sqlmodel import Field, Relationship, SQLModel
import strawberry
class City(SQLModel, table=True):
id: Optional[int] = Field(primary_key=True, default=None)
name: str = Field()
population: int = Field()
class Manager(SQLModel, table=... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((196, 233), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)', 'default': 'None'}), '(primary_key=True, default=None)\n', (201, 233), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((250, 257), 'sqlmodel.Field', 'Field', ([], {}), '()\n', (255, 257), False, 'from sqlmodel import Field, Relatio... |
import io
import numpy as np
import megengine.core.tensor.megbrain_graph as G
import megengine.utils.comp_graph_tools as cgtools
from megengine import tensor
from megengine.jit import trace
from megengine.utils.network_node import VarNode
def _default_compare_fn(x, y):
if isinstance(x, np.ndarray):
np.t... | [
"megengine.jit.trace",
"megengine.tensor",
"megengine.utils.comp_graph_tools.GraphInference",
"megengine.utils.network_node.VarNode"
] | [((316, 360), 'numpy.testing.assert_allclose', 'np.testing.assert_allclose', (['x', 'y'], {'rtol': '(1e-06)'}), '(x, y, rtol=1e-06)\n', (342, 360), True, 'import numpy as np\n'), ((653, 677), 'megengine.tensor', 'tensor', (['x'], {'device': 'device'}), '(x, device=device)\n', (659, 677), False, 'from megengine import t... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.