code stringlengths 110 64.5k | apis list | extract_api stringlengths 123 69.9k |
|---|---|---|
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 tutorial002 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... |
# Lettura dati con SQLModel, all, first, one; update; delete
# https://sqlmodel.tiangolo.com/tutorial/select/ e seguito
from typing import Optional
from sqlmodel import Field, SQLModel, Session, create_engine, select
class Tag(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
na... | [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.select",
"sqlmodel.Field"
] | [((536, 572), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (549, 572), False, 'from sqlmodel import Field, SQLModel, Session, create_engine, select\n'), ((276, 313), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=... |
# 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.core.tensor.dtype.get_scale",
"megengine.quantization.quantize.quantize_qat",
"megengine.tensor",
"megengine.core.tensor.dtype.get_zero_point",
"megengine.core.tensor.dtype.qint8",
"megengine.core.tensor.dtype.quint8",
"megengine.module.quant_dequant.QuantStub",
"megengine.quantization.util... | [((1033, 1050), 'megengine.quantization.quantize.quantize_qat', 'quantize_qat', (['net'], {}), '(net)\n', (1045, 1050), False, 'from megengine.quantization.quantize import quantize_qat\n'), ((2023, 2034), 'test.utils.LinearOpr', 'LinearOpr', ([], {}), '()\n', (2032, 2034), False, 'from test.utils import LinearOpr\n'), ... |
# 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.Tensor"
] | [((2414, 2472), 'numpy.arange', 'np.arange', (['min_value', '(max_value + 2)', '(2)'], {'dtype': 'low_bit_type'}), '(min_value, max_value + 2, 2, dtype=low_bit_type)\n', (2423, 2472), True, 'import numpy as np\n'), ((2483, 2530), 'megengine.tensor.Tensor', 'Tensor', (['data'], {'dtype': 'low_bit_type', 'device': '"""xp... |
from sqlmodel import SQLModel, create_engine
from sqlalchemy.orm import sessionmaker
from sqlmodel.ext.asyncio.session import AsyncSession, AsyncEngine
from app.settings import Settings
settings = Settings()
engine = AsyncEngine(create_engine(settings.ASYNC_DATABASE_URI, echo=True, future=True))
async def init_db():... | [
"sqlmodel.create_engine"
] | [((198, 208), 'app.settings.Settings', 'Settings', ([], {}), '()\n', (206, 208), False, 'from app.settings import Settings\n'), ((231, 297), 'sqlmodel.create_engine', 'create_engine', (['settings.ASYNC_DATABASE_URI'], {'echo': '(True)', 'future': '(True)'}), '(settings.ASYNC_DATABASE_URI, echo=True, future=True)\n', (2... |
"""
Biot problem with the non-penetration BC on the Walls boundary region.
The non-penetration condition is enforced weakly using the Lagrange
multiplier approach. There is also a rigid body movement constraint
imposed on the Outlet region using the linear combination boundary
conditions.
"""
from biot_npbc import cinc... | [
"sfepy.base.base.Struct"
] | [((699, 774), '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", (705, 774), False, 'from sfepy.base.base import Struct\n'), ((891, 968), 'sfepy.b... |
from typing import Optional
from sqlalchemy import create_engine, select
from sqlalchemy.orm import Session
from sqlmodel import Field, SQLModel
def test_allow_instantiation_without_arguments(clear_sqlmodel):
class Item(SQLModel):
id: Optional[int] = Field(default=None, primary_key=True)
name: st... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.SQLModel.metadata.clear"
] | [((426, 461), 'sqlalchemy.create_engine', 'create_engine', (['"""sqlite:///:memory:"""'], {}), "('sqlite:///:memory:')\n", (439, 461), False, 'from sqlalchemy import create_engine, select\n'), ((466, 502), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (494, 502... |
import math
import megengine.module as M
import megengine.functional as F
class PositionEncodingSine(M.Module):
"""
This is a sinusoidal position encoding that generalized to 2-dimensional images
"""
def __init__(self, d_model, max_shape=(256, 256)):
"""
Args:
max_shape (t... | [
"megengine.functional.arange",
"megengine.functional.cos",
"megengine.functional.zeros",
"megengine.functional.ones",
"megengine.functional.expand_dims",
"megengine.functional.sin"
] | [((446, 476), 'megengine.functional.zeros', 'F.zeros', (['(d_model, *max_shape)'], {}), '((d_model, *max_shape))\n', (453, 476), True, 'import megengine.functional as F\n'), ((751, 782), 'megengine.functional.expand_dims', 'F.expand_dims', (['div_term', '(1, 2)'], {}), '(div_term, (1, 2))\n', (764, 782), True, 'import ... |
from typing import Optional
from sqlmodel import Field, SQLModel
class Example(SQLModel, table=True):
"""测试一下"""
id: Optional[int] = Field(default=None, primary_key=True)
message: str
| [
"sqlmodel.Field"
] | [((145, 182), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (150, 182), False, 'from sqlmodel import Field, SQLModel\n')] |
# -*- 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.TensorDict",
"megengine.load",
"megengine.core.tensor"
] | [((1024, 1053), 'helpers.graph_mode', 'graph_mode', (['"""eager"""', '"""static"""'], {}), "('eager', 'static')\n", (1034, 1053), False, 'from helpers import MLP, graph_mode\n'), ((1155, 1160), 'helpers.MLP', 'MLP', ([], {}), '()\n', (1158, 1160), False, 'from helpers import MLP, graph_mode\n'), ((1238, 1250), 'megengi... |
from sfepy.base.base import Struct, output, insert_as_static_method, \
pause, debug
class Application( Struct ):
"""Base class for applications.
Subclasses should implement: __init__(), call().
Automates parametric studies, see parametrize().
"""
def __init__( self, conf, options, output_pre... | [
"sfepy.base.base.insert_as_static_method",
"sfepy.base.base.Struct.__init__"
] | [((345, 423), 'sfepy.base.base.Struct.__init__', 'Struct.__init__', (['self'], {'conf': 'conf', 'options': 'options', 'output_prefix': 'output_prefix'}), '(self, conf=conf, options=options, output_prefix=output_prefix)\n', (360, 423), False, 'from sfepy.base.base import Struct, output, insert_as_static_method, pause, d... |
import time
import numpy as nm
import warnings
import scipy.sparse as sps
warnings.simplefilter('ignore', sps.SparseEfficiencyWarning)
from sfepy.base.base import output, get_default, assert_, try_imports, Struct
from sfepy.solvers.solvers import make_get_conf, LinearSolver
def standard_call(call):
"""
Dec... | [
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.solvers.solvers.LinearSolver.__init__",
"sfepy.base.base.assert_",
"sfepy.base.base.output.set_output_prefix",
"sfepy.discrete.Problem.from_conf",
"sfepy.discrete.state.State",
"sfepy.base.conf.get_standard_keywords",
"sfepy.base.base.get_default",
"sf... | [((77, 137), 'warnings.simplefilter', 'warnings.simplefilter', (['"""ignore"""', 'sps.SparseEfficiencyWarning'], {}), "('ignore', sps.SparseEfficiencyWarning)\n", (98, 137), False, 'import warnings\n'), ((556, 568), 'time.clock', 'time.clock', ([], {}), '()\n', (566, 568), False, 'import time\n'), ((585, 613), 'sfepy.b... |
"""add verified result to application
Revision ID: d8a156ffaeae
Revises: <KEY>
Create Date: 2022-03-30 16:00:13.195216
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = "d8a156ffaeae"
down_revision = "<KEY>"
branch_labels = None
depends_on = None
... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((659, 702), 'alembic.op.drop_column', 'op.drop_column', (['"""job_applicant"""', '"""verified"""'], {}), "('job_applicant', 'verified')\n", (673, 702), False, 'from alembic import op\n'), ((477, 511), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (509, 511), False, 'import ... |
"""All database connection information is defined here"""
from sqlmodel import SQLModel, create_engine
from sqlalchemy.engine import Engine
from sqlalchemy import event
DB_FILE = "devices.db"
sqlite_url = f"sqlite:///{DB_FILE}"
connect_args = {"check_same_thread": False}
engine = create_engine(
sqlite_url, conne... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.create_engine"
] | [((284, 347), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'connect_args': 'connect_args', 'echo': '(True)'}), '(sqlite_url, connect_args=connect_args, echo=True)\n', (297, 347), False, 'from sqlmodel import SQLModel, create_engine\n'), ((518, 554), 'sqlalchemy.event.listens_for', 'event.listens_for', (... |
from datetime import datetime
from typing import List, Optional
from sqlmodel import Column, DateTime, Field, Relationship, SQLModel
class ObserverBase(SQLModel):
phone: str
email: str
class Config:
anystr_strip_whitespace = True
anystr_lower = True
class Observer(ObserverBase, table=T... | [
"sqlmodel.Field",
"sqlmodel.Column",
"sqlmodel.Relationship"
] | [((350, 387), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (355, 387), False, 'from sqlmodel import Column, DateTime, Field, Relationship, SQLModel\n'), ((428, 521), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""observer"""',... |
from sqlmodel import SQLModel, Field
from typing import Optional, List
from pydantic import validator
# --- model ---
class User(SQLModel, table=True):
id: Optional[int] = Field(None, primary_key=True)
username: str
password: str
# --- serializers ---
class UserOut(SQLModel):
username: str
class... | [
"sqlmodel.Field"
] | [((178, 207), 'sqlmodel.Field', 'Field', (['None'], {'primary_key': '(True)'}), '(None, primary_key=True)\n', (183, 207), False, 'from sqlmodel import SQLModel, Field\n')] |
#%%
import numpy as np
from sfepy.discrete.fem import Mesh, FEDomain, Field
mesh_path = 'C:/Users/lzy71/miniconda3/envs/lego/lib/site-packages/sfepy/meshes/2d/rectangle_tri.mesh'
#%%
mesh = Mesh.from_file(mesh_path)
domain = FEDomain('domain', mesh)
min_x, max_x = domain.get_mesh_bounding_box()[:, 0]
eps = 1e-8 * (m... | [
"sfepy.discrete.Material",
"sfepy.discrete.FieldVariable",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.terms.Term.new",
"sfepy.discrete.Equations",
"sfepy.discrete.Integral",
"sfepy.mechanics.matcoefs.stiffness_from_lame",
"sfepy.discrete.Equation",
"sfepy.discrete.fem.Field.from_args",
"sfepy.dis... | [((192, 217), 'sfepy.discrete.fem.Mesh.from_file', 'Mesh.from_file', (['mesh_path'], {}), '(mesh_path)\n', (206, 217), False, 'from sfepy.discrete.fem import Mesh, FEDomain, Field\n'), ((227, 251), 'sfepy.discrete.fem.FEDomain', 'FEDomain', (['"""domain"""', 'mesh'], {}), "('domain', mesh)\n", (235, 251), False, 'from ... |
# -*- 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.nn.cross_entropy",
"megengine.functional.nn.ctc_loss",
"megengine.tensor"
] | [((627, 658), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['data', 'label'], {}), '(data, label)\n', (645, 658), True, 'import megengine.functional as F\n'), ((764, 795), 'megengine.functional.nn.cross_entropy', 'F.nn.cross_entropy', (['data', 'label'], {}), '(data, label)\n', (782, 795), True, 'imp... |
# -*- 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.functional.sum",
"megengine.functional.grad",
"megengine.module.BatchNorm2d"
] | [((542, 559), 'numpy.random.seed', 'np.random.seed', (['(0)'], {}), '(0)\n', (556, 559), True, 'import numpy as np\n'), ((846, 854), 'megengine.functional.sum', 'F.sum', (['b'], {}), '(b)\n', (851, 854), True, 'import megengine.functional as F\n'), ((868, 904), 'megengine.functional.grad', 'F.grad', (['c', 'x'], {'use_... |
import numpy as np
import megengine as mge
import megengine.autodiff as ad
import megengine.optimizer as optimizer
from megengine import Parameter, tensor
from megengine.core.tensor.raw_tensor import RawTensor
from megengine.module import Module
class Simple(Module):
def __init__(self):
super().__init__(... | [
"megengine.get_default_device",
"megengine.load",
"megengine.tensor",
"megengine.set_default_device",
"megengine.autodiff.GradManager",
"megengine.Parameter"
] | [((636, 650), 'megengine.tensor', 'tensor', (['[2.34]'], {}), '([2.34])\n', (642, 650), False, 'from megengine import Parameter, tensor\n'), ((1031, 1072), 'megengine.load', 'mge.load', (['model_name'], {'map_location': '"""cpu0"""'}), "(model_name, map_location='cpu0')\n", (1039, 1072), True, 'import megengine as mge\... |
from datetime import datetime
from os import getenv
from typing import Optional
from fastapi import FastAPI
import strawberry
from strawberry.asgi import GraphQL
from sqlmodel import create_engine, SQLModel
from api.models import PostQL
from api.crud import create_post, get_posts
ENGINE = create_engine(getenv("DATAB... | [
"sqlmodel.SQLModel.metadata.create_all"
] | [((908, 957), 'strawberry.Schema', 'strawberry.Schema', ([], {'query': 'Query', 'mutation': 'Mutation'}), '(query=Query, mutation=Mutation)\n', (925, 957), False, 'import strawberry\n'), ((959, 995), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['ENGINE'], {}), '(ENGINE)\n', (987, 995), Fal... |
from popol.db.sqlmodel import models
from sqlmodel import Field
class Account(models.Model, table=True):
username: str = Field(max_length=255, nullable=False)
password: str = Field(max_length=255, nullable=False)
class Counter(models.Model, table=True):
value: int
| [
"sqlmodel.Field"
] | [((127, 164), 'sqlmodel.Field', 'Field', ([], {'max_length': '(255)', 'nullable': '(False)'}), '(max_length=255, nullable=False)\n', (132, 164), False, 'from sqlmodel import Field\n'), ((185, 222), 'sqlmodel.Field', 'Field', ([], {'max_length': '(255)', 'nullable': '(False)'}), '(max_length=255, nullable=False)\n', (19... |
#!/usr/bin/env python
r"""
This example shows the use of the `dw_tl_he_genyeoh` hyperelastic term, whose
contribution to the deformation energy density per unit reference volume is
given by
.. math::
W = K \, \left( \overline I_1 - 3 \right)^{p}
where :math:`\overline I_1` is the first main invariant of the devia... | [
"sfepy.mesh.mesh_generators.gen_block_mesh",
"sfepy.solvers.ts_solvers.SimpleTimeSteppingSolver",
"sfepy.homogenization.utils.define_box_regions",
"sfepy.solvers.nls.Newton",
"sfepy.discrete.Problem",
"sfepy.discrete.Integral",
"sfepy.discrete.fem.Field.from_args",
"sfepy.base.base.Struct",
"sfepy.d... | [((4494, 4520), 'sys.path.append', 'sys.path.append', (['SFEPY_DIR'], {}), '(SFEPY_DIR)\n', (4509, 4520), False, 'import sys\n'), ((5366, 5546), 'numpy.array', 'np.array', (['[(2 * coef * exp * (stretch ** 2 + 2 / stretch - 3) ** (exp - 1) * (stretch -\n stretch ** -2) if stretch ** 2 + 2 / stretch > 3 else 0.0) for... |
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
# Copyright (c) 2020 <NAME>
# This file has been modified by Megvii ("Megvii Modifications").
# All Megvii Modifications are Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
"""EfficientNet Series
EfficientNet: `"EfficientNet: Rethinking... | [
"megengine.hub.pretrained"
] | [((3301, 3328), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (3326, 3328), False, 'from basecls.utils import recursive_update, registers\n'), ((8976, 9003), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (9001, 9003), False, 'from b... |
# -*- 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._internal.opr.elem.exp",
"megengine._internal.opr.pooling",
"megengine._internal.opr.add_axis",
"megengine._internal.opr.assert_equal",
"megengine._internal.opr.elemwise",
"megengine._internal.opr.reshape",
"megengine._internal.opr.indexing_one_hot",
"megengine._internal.opr.batch_norm",
... | [((1169, 1217), 'megengine._internal.opr.matrix_mul', 'mgb.opr.matrix_mul', (['inp', 'weight'], {'transposeB': '(True)'}), '(inp, weight, transposeB=True)\n', (1187, 1217), True, 'import megengine._internal as mgb\n'), ((7082, 7204), 'megengine._internal.opr.pooling', 'mgb.opr.pooling', (['inp'], {'mode': 'mode', 'form... |
from fastapi import APIRouter, Depends, HTTPException, Query, Path
from sqlmodel import Session, select
from sqlalchemy.exc import IntegrityError
from typing import List, Any
import datetime as dt
from app.src.common.utils import profiling_api
from app.src.models.product import (
Product,
ProductRead,
Prod... | [
"sqlmodel.select"
] | [((751, 762), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (760, 762), False, 'from fastapi import APIRouter, Depends, HTTPException, Query, Path\n'), ((825, 845), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (832, 845), False, 'from fastapi import APIRouter, Depends, HTTPException, Qu... |
# 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.Session",
"sqlmodel.select"
] | [((1102, 1149), 'typer.Typer', 'typer.Typer', ([], {'name': '"""model"""', 'no_args_is_help': '(True)'}), "(name='model', no_args_is_help=True)\n", (1113, 1149), False, 'import typer\n'), ((1248, 1272), 'typer.Option', 'typer.Option', (['None', '"""-t"""'], {}), "(None, '-t')\n", (1260, 1272), False, 'import typer\n'),... |
# 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.quantization.quantize.quantize_qat",
"megengine.module.Elemwise",
"megengine.traced_module.fake_quant.FakeQuantize",
"megengine.tensor",
"megengine.quantization.utils.create_qparams",
"megengine.core.tensor.dtype.get_scale",
"megengine.module.quant_dequant.QuantStub",
"megengine.core.tensor... | [((1132, 1149), 'megengine.quantization.quantize.quantize_qat', 'quantize_qat', (['net'], {}), '(net)\n', (1144, 1149), False, 'from megengine.quantization.quantize import quantize_qat\n'), ((2064, 2081), 'megengine.quantization.quantize.quantize_qat', 'quantize_qat', (['net'], {}), '(net)\n', (2076, 2081), False, 'fro... |
# mixed formulation
# 07.08.2009
#!
#! Homogenization: Linear Elasticity
#! =================================
#$ \centerline{Example input file, \today}
#! Homogenization of heterogeneous linear elastic material - mixed formulation
import numpy as nm
import sfepy.discrete.fem.periodic as per
from sfepy.mechanics.mat... | [
"sfepy.homogenization.utils.get_box_volume",
"sfepy.mechanics.matcoefs.stiffness_from_youngpoisson_mixed",
"sfepy.homogenization.recovery.compute_stress_strain_u",
"sfepy.mechanics.matcoefs.bulk_from_youngpoisson",
"sfepy.homogenization.utils.define_box_regions",
"sfepy.base.base.Struct",
"sfepy.homogen... | [((968, 1046), '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", (974, 1046), False, 'from sfepy.base.base import Struct\n'), ((1132, 1243)... |
from sqlalchemy.orm import Session
from sqlmodel import select
from sqlalchemy.exc import SQLAlchemyError
from typing import Any
# import sys
#
# sys.path.append("..")
from app.db import models, pagination,session_scope
from app.util import passutil, schemas
from app.logs import fastapi_logger
from app.crud... | [
"sqlmodel.select"
] | [((511, 541), 'app.crud.get_user_password', 'get_user_password', ([], {'email': 'email'}), '(email=email)\n', (528, 541), False, 'from app.crud import get_user, get_user_password\n'), ((799, 814), 'app.db.session_scope', 'session_scope', ([], {}), '()\n', (812, 814), False, 'from app.db import models, pagination, sessi... |
#!/usr/bin/env python
"""
Dispersion analysis of a heterogeneous finite scale periodic cell.
The periodic cell mesh has to contain two subdomains Y1 (with the cell ids 1),
Y2 (with the cell ids 2), so that different material properties can be defined
in each of the subdomains (see ``--pars`` option). The command line ... | [
"sfepy.base.conf.dict_from_string",
"sfepy.solvers.ts.TimeStepper",
"sfepy.linalg.utils.output_array_stats",
"sfepy.base.ioutils.remove_files_patterns",
"sfepy.base.base.Struct.__init__",
"sfepy.base.ioutils.ensure_path",
"sfepy.discrete.fem.periodic.set_accuracy",
"sfepy.mechanics.matcoefs.lame_from_... | [((4031, 4051), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (4046, 4051), False, 'import sys\n'), ((5102, 5210), 'sfepy.mechanics.units.apply_unit_multipliers', 'apply_unit_multipliers', (['pars', "['stress', 'one', 'density', 'stress', 'one', 'density']", 'unit_multipliers'], {}), "(pars, ['str... |
import json
from sfm.utils import validate_signature, calc_signature
from sfm.dependencies import get_db
from sfm.models import WorkItemCreate, Project, CommitCreate, WorkItem, WorkItemUpdate
from typing import List, Optional
from sqlmodel import Session, select, and_
from fastapi import APIRouter, HTTPException, Depe... | [
"sqlmodel.select"
] | [((721, 735), 'sfm.config.get_settings', 'get_settings', ([], {}), '()\n', (733, 735), False, 'from sfm.config import get_settings\n'), ((747, 770), 'sfm.logger.create_logger', 'create_logger', (['__name__'], {}), '(__name__)\n', (760, 770), False, 'from sfm.logger import create_logger\n'), ((782, 793), 'fastapi.APIRou... |
from pydantic.types import Optional
from sqlmodel import Field, Relationship, SQLModel
from api.public.team.models import Team
class HeroBase(SQLModel):
name: str
secret_name: str
age: Optional[int] = None
team_id: Optional[int] = Field(default=None, foreign_key="team.id")
class Config:
... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((251, 293), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""team.id"""'}), "(default=None, foreign_key='team.id')\n", (256, 293), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((604, 641), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default... |
from typing import Optional
from sqlmodel import Field, Session, SQLModel, create_engine
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:///{sqlite... | [
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.create_engine",
"sqlmodel.Field"
] | [((343, 379), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (356, 379), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((150, 187), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, pr... |
from fastapi.exceptions import HTTPException
import pytest
from sqlmodel import select, Session
from sqlmodel.main import SQLModel
from sfm.routes.projects import crud
from tests.conftest import hashed_token1, hashed_token2
from sfm.models import Project, ProjectCreate, ProjectUpdate
# get_all
def test_get_all(db, s... | [
"sqlmodel.select"
] | [((409, 425), 'sfm.routes.projects.crud.get_all', 'crud.get_all', (['db'], {}), '(db)\n', (421, 425), False, 'from sfm.routes.projects import crud\n'), ((1792, 1824), 'sfm.routes.projects.crud.get_by_id', 'crud.get_by_id', (['db'], {'project_id': '(1)'}), '(db, project_id=1)\n', (1806, 1824), False, 'from sfm.routes.pr... |
from datetime import datetime
try:
from humps.main import depascalize
from sqlalchemy import Column, DateTime
from sqlalchemy.orm.decl_api import declared_attr
from sqlmodel import Field, SQLModel
except ImportError:
raise RuntimeError(
"SQLModel is not installed. Please install it with `p... | [
"sqlmodel.Field"
] | [((542, 565), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (547, 565), False, 'from sqlmodel import Field, SQLModel\n'), ((886, 911), 'humps.main.depascalize', 'depascalize', (['cls.__name__'], {}), '(cls.__name__)\n', (897, 911), False, 'from humps.main import depascalize\n'), ((... |
# -*- 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.module.ReLU",
"megengine.module.init.ones_",
"megengine.module.init.msra_normal_",
"megengine.functional.nn.interpolate",
"megengine.module.init.zeros_",
"megengine.module.Conv2d",
"megengine.functional.mean",
"megengine.module.Dropout",
"megengine.module.BatchNorm2d",
"megengine.functi... | [((2386, 2409), 'megengine.functional.mean', 'F.mean', (['x', '[2, 3]', '(True)'], {}), '(x, [2, 3], True)\n', (2392, 2409), True, 'import megengine.functional as F\n'), ((2453, 2499), 'megengine.functional.nn.interpolate', 'F.nn.interpolate', (['gp', '(x.shape[2], x.shape[3])'], {}), '(gp, (x.shape[2], x.shape[3]))\n'... |
# -*- 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.test.assertTensorClose",
"megengine.core.Graph",
"megengine.functional.softmax"
] | [((853, 858), 'helpers.MLP', 'MLP', ([], {}), '()\n', (856, 858), False, 'from helpers import MLP\n'), ((952, 968), 'megengine.functional.softmax', 'F.softmax', (['pred0'], {}), '(pred0)\n', (961, 968), True, 'import megengine.functional as F\n'), ((1395, 1430), 'megengine.test.assertTensorClose', 'assertTensorClose', ... |
# Creare connessioni tra tabelle M:N (many to many): Product e Tags
# https://sqlmodel.tiangolo.com/tutorial/many-to-many/
# e seguito
from typing import Optional, List
from sqlmodel import Field, SQLModel, Session,\
Relationship, create_engine, select
# Tabella di associazione tra Tag e Product
... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.Field",
"sqlmodel.select",
"sqlmodel.create_engine",
"sqlmodel.Relationship"
] | [((1400, 1436), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (1413, 1436), False, 'from sqlmodel import Field, SQLModel, Session, Relationship, create_engine, select\n'), ((392, 451), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""... |
"""Add countries
Revision ID: <KEY>
Revises: 423e059e8b64
Create Date: 2022-02-12 07:51:13.003045+00:00
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
# revision identifiers, used by Alembic.
revision = "<KEY>"
down_revision = "423e059e8b64"
branch_labels = None
depends_on = None
def upgrade():... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((701, 786), 'alembic.op.create_foreign_key', 'op.create_foreign_key', (['None', '"""applications"""', '"""countries"""', "['country_id']", "['id']"], {}), "(None, 'applications', 'countries', ['country_id'], ['id']\n )\n", (722, 786), False, 'from alembic import op\n'), ((906, 966), 'alembic.op.drop_constraint', '... |
from typing import Optional
from fastapi import FastAPI
from sqlmodel import Session, SQLModel, create_engine
from .abstractions import MultipleModels, register_endpoints
class HeroBase(SQLModel):
name: str
secret_name: str
age: Optional[int] = None
class HeroRead(HeroBase):
id: int
hero_models ... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.create_engine"
] | [((579, 642), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)', 'connect_args': 'connect_args'}), '(sqlite_url, echo=True, connect_args=connect_args)\n', (592, 642), False, 'from sqlmodel import Session, SQLModel, create_engine\n'), ((802, 811), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n... |
# 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.func.count",
"sqlmodel.select",
"sqlmodel.Session"
] | [((1168, 1200), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (1182, 1200), False, 'import pytest\n'), ((1311, 1331), 'sqlmodel.select', 'select', (['Parent.label'], {}), '(Parent.label)\n', (1317, 1331), False, 'from sqlmodel import Session, func, select\n'), ((1344, 13... |
# 10.07.2007, c
# last revision: 25.03.2008
from sfepy import data_dir
filename_meshes = ['/meshes/3d/cube_medium_tetra.mesh',
'/meshes/3d/cube_medium_tetra.mesh',
'/meshes/3d/cube_medium_hexa.mesh']
filename_meshes = [data_dir + name for name in filename_meshes]
all_your_bases =... | [
"sfepy.base.base.IndexedStruct",
"sfepy.applications.solve_pde"
] | [((616, 677), 'numpy.array', 'nm.array', (['([1.0] * dim + [0.0] * (sym - dim))'], {'dtype': 'nm.float64'}), '([1.0] * dim + [0.0] * (sym - dim), dtype=nm.float64)\n', (624, 677), True, 'import numpy as nm\n'), ((690, 704), 'numpy.outer', 'nm.outer', (['o', 'o'], {}), '(o, o)\n', (698, 704), True, 'import numpy as nm\n... |
# -*- coding: utf-8 -*-
# This repo 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.max",
"megengine.functional.argmax",
"megengine.functional.full_like"
] | [((1208, 1232), 'megengine.functional.argmax', 'F.argmax', (['matrix'], {'axis': '(0)'}), '(matrix, axis=0)\n', (1216, 1232), True, 'import megengine.functional as F\n'), ((1286, 1316), 'megengine.functional.full_like', 'F.full_like', (['match_indices', '(-1)'], {}), '(match_indices, -1)\n', (1297, 1316), True, 'import... |
#!/usr/bin/env python
"""
Show terms use in problem description files in the given directory.
"""
from __future__ import absolute_import
import sys
import six
sys.path.append('.')
import os
from argparse import ArgumentParser
from sfepy.base.base import output, dict_from_keys_init, ordered_iteritems
from sfepy.base.co... | [
"sfepy.terms.term_table.keys",
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.base.base.ordered_iteritems",
"sfepy.base.conf.get_standard_keywords",
"sfepy.discrete.equations.parse_definition",
"sfepy.base.base.output",
"sfepy.base.ioutils.locate_files"
] | [((159, 179), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (174, 179), False, 'import sys\n'), ((623, 658), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '__doc__'}), '(description=__doc__)\n', (637, 658), False, 'from argparse import ArgumentParser\n'), ((1146, 1181), 'os.pat... |
# -*- 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.quantization.utils.fake_quant_tensor",
"megengine.functional.maximum",
"megengine.quantization.utils.lsq_forward",
"megengine.functional.full",
"megengine.core.tensor.utils.make_shape_tuple",
"megengine.quantization.utils.create_qparams",
"megengine.functional.ones_like",
"megengine.core.au... | [((2467, 2511), 'numpy.ones', 'np.ones', ([], {'shape': '(1, 2, 3, 4)', 'dtype': '"""float32"""'}), "(shape=(1, 2, 3, 4), dtype='float32')\n", (2474, 2511), True, 'import numpy as np\n'), ((2615, 2645), 'megengine.tensor', 'mge.tensor', (['x'], {'dtype': '"""float32"""'}), "(x, dtype='float32')\n", (2625, 2645), True, ... |
from enum import Enum
from typing import TYPE_CHECKING, Optional, Set
from sqlalchemy import Column
from sqlalchemy import Enum as SQLEnum
from sqlalchemy import ForeignKey, Integer
from sqlmodel import Field, Relationship, SQLModel
from .application import Status
if TYPE_CHECKING:
from .message import Message
... | [
"sqlmodel.Relationship"
] | [((1659, 1700), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""recipients"""'}), "(back_populates='recipients')\n", (1671, 1700), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((1281, 1295), 'sqlalchemy.Enum', 'SQLEnum', (['Group'], {}), '(Group)\n', (1288, 1295), True, 'from sql... |
from sqlmodel import SQLModel, Field, JSON, Relationship, VARCHAR
from pydantic import BaseModel
from datetime import datetime
from typing import List, Optional
from sqlalchemy import String, Column
class ServerCatagoryLink(SQLModel, table=True):
server_id: Optional[int] = Field(
default=None, foreign_key... | [
"sqlmodel.Field",
"sqlmodel.Relationship"
] | [((280, 342), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""server.id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='server.id', primary_key=True)\n", (285, 342), False, 'from sqlmodel import SQLModel, Field, JSON, Relationship, VARCHAR\n'), ((390, 454), 'sqlmodel.Field', 'Field',... |
import typing as t
if t.TYPE_CHECKING:
from .other import DB_AccessToken, DB_APIKey
from .discussions import DB_Discussion
from datetime import datetime
from sqlmodel import SQLModel, Field, Relationship, Column, JSON
from ..extensions.tags import DB_Tag, DB_TagUser
class DB_User(SQLModel, table=True):
... | [
"sqlmodel.Relationship",
"sqlmodel.Field",
"sqlmodel.Column"
] | [((372, 409), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (377, 409), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((494, 550), 'sqlmodel.Field', 'Field', ([], {'max_length': '(100)', 'sa_column_kwargs': "{'unique'... |
from datetime import datetime
from sqlmodel import Session, SQLModel, create_engine, text
import sqlite3
database_loc = "backend/database.sqlite"
con_str = f"sqlite:///{database_loc}"
engine = create_engine(con_str, echo=True)
sqlite3_engine = sqlite3.connect(f"{database_loc}")
def get_session():
session = Sess... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.text",
"sqlmodel.create_engine"
] | [((195, 228), 'sqlmodel.create_engine', 'create_engine', (['con_str'], {'echo': '(True)'}), '(con_str, echo=True)\n', (208, 228), False, 'from sqlmodel import Session, SQLModel, create_engine, text\n'), ((246, 280), 'sqlite3.connect', 'sqlite3.connect', (['f"""{database_loc}"""'], {}), "(f'{database_loc}')\n", (261, 28... |
from __future__ import annotations
import inspect
from functools import wraps
from typing import Any, List, Type, TypeVar
from fastapi.encoders import jsonable_encoder
from sqlmodel import SQLModel, select
from sqlmodel.ext.asyncio.session import AsyncSession
Self = TypeVar("Self", bound="Base")
class InvalidTable... | [
"sqlmodel.select"
] | [((270, 299), 'typing.TypeVar', 'TypeVar', (['"""Self"""'], {'bound': '"""Base"""'}), "('Self', bound='Base')\n", (277, 299), False, 'from typing import Any, List, Type, TypeVar\n'), ((836, 847), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (841, 847), False, 'from functools import wraps\n'), ((2278, 2300), ... |
import megengine as mge
import megengine.functional as F
from megengine.core import tensor
from layers.nms import gpu_nms
from config import config
from det_opr.bbox_opr import bbox_transform_inv_opr, clip_boxes_opr, \
filter_boxes_opr
def find_top_rpn_proposals(is_train, rpn_bbox_offsets_list, rpn_cls_prob_list,... | [
"megengine.functional.argsort",
"megengine.functional.concat",
"megengine.functional.softmax",
"megengine.core.tensor"
] | [((2080, 2118), 'megengine.functional.concat', 'F.concat', (['batch_proposals_list'], {'axis': '(0)'}), '(batch_proposals_list, axis=0)\n', (2088, 2118), True, 'import megengine.functional as F\n'), ((2141, 2175), 'megengine.functional.concat', 'F.concat', (['batch_probs_list'], {'axis': '(0)'}), '(batch_probs_list, ax... |
"""
Functions to visualize the geometry elements and numbering and orientation of
their facets (edges and faces).
The standard geometry elements can be plotted by running::
$ python sfepy/postprocess/plot_facets.py
"""
import numpy as nm
import matplotlib.pyplot as plt
from sfepy.linalg import (get_perpendiculars,... | [
"sfepy.linalg.normalize_vectors",
"sfepy.discrete.fem.geometry_element.geometry_data.iteritems",
"sfepy.linalg.get_perpendiculars",
"sfepy.discrete.fem.geometry_element.GeometryElement",
"sfepy.postprocess.plot_dofs.plot_global_dofs",
"sfepy.postprocess.plot_dofs.plot_mesh",
"sfepy.linalg.make_axis_rota... | [((582, 641), 'sfepy.postprocess.plot_dofs.plot_mesh', 'plot_mesh', (['ax', 'gel.coors', '[gel.conn]', 'gel.edges'], {'show': '(False)'}), '(ax, gel.coors, [gel.conn], gel.edges, show=False)\n', (591, 641), False, 'from sfepy.postprocess.plot_dofs import _get_axes, plot_mesh, plot_global_dofs\n'), ((651, 705), 'sfepy.p... |
import pytest
from typing import Generator, Dict
from sqlmodel import Session, SQLModel, create_engine
from sqlmodel.pool import StaticPool
from fastapi.testclient import TestClient
from app.models import *
from app.main import app
from app.api.deps import get_db
@pytest.fixture(name="session")
def session_fixture() ... | [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all"
] | [((267, 297), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""session"""'}), "(name='session')\n", (281, 297), False, 'import pytest\n'), ((593, 622), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""client"""'}), "(name='client')\n", (607, 622), False, 'import pytest\n'), ((853, 883), 'pytest.fixture', 'pyt... |
from typing import Optional # (1)
from sqlmodel import Field, SQLModel, create_engine # (2)
class Hero(SQLModel, table=True): # (3)
id: Optional[int] = Field(default=None, primary_key=True) # (4)
name: str # (5)
secret_name: str # (6)
age: Optional[int] = None # (7)
sqlite_file_name = "datab... | [
"sqlmodel.create_engine",
"sqlmodel.Field",
"sqlmodel.SQLModel.metadata.create_all"
] | [((397, 433), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (410, 433), False, 'from sqlmodel import Field, SQLModel, create_engine\n'), ((162, 199), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import bisect
import datetime
import math
import os
import pickle
import time
from typing import Optional
import megengine as mge
import megengine.distributed as dist
import megengine.module as M
from basecore.config import ConfigDict
fr... | [
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size"
] | [((1244, 1353), 'basecore.utils.Checkpoint', 'Checkpoint', (['save_dir', 'model'], {'tag_file': 'None', 'optimizer': 'optim', 'scaler': 'scaler', 'progress': 'progress'}), '(save_dir, model, tag_file=None, optimizer=optim, scaler=scaler,\n progress=progress, **ckpt_kws)\n', (1254, 1353), False, 'from basecore.utils ... |
#!/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
from basecls.layers import ClsHead, MBV3Head, VGGHead, build_head
@pytest.mark.parametrize("w_in", [4])
@pytest.mark.parametrize(
"head_args",
... | [
"megengine.Tensor"
] | [((238, 274), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[4]'], {}), "('w_in', [4])\n", (261, 274), False, 'import pytest\n'), ((1128, 1172), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""norm_name"""', "['BN']"], {}), "('norm_name', ['BN'])\n", (1151, 1172), False, 'import pyt... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import argparse
import importlib
import multiprocessing as mp
import os
import sys
import megengine as mge
import megengine.distributed as dist
from basecore.config import ConfigDict
from loguru import logger
from basecls.engine import ... | [
"megengine.distributed.get_rank",
"megengine.functional.debug_param.set_execution_strategy",
"megengine.device.get_device_count",
"megengine.distributed.group_barrier",
"megengine.distributed.launcher"
] | [((632, 657), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (655, 657), False, 'import argparse\n'), ((1220, 1256), 'importlib.import_module', 'importlib.import_module', (['module_name'], {}), '(module_name)\n', (1243, 1256), False, 'import importlib\n'), ((1390, 1421), 'os.path.abspath', 'os.... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import argparse
import importlib
import os
import sys
import megengine as mge
import megengine.distributed as dist
from basecore.config import ConfigDict
from loguru import logger
from basecls.models import build_model, load_model, sync... | [
"megengine.functional.debug_param.set_execution_strategy",
"megengine.device.get_device_count",
"megengine.distributed.group_barrier",
"megengine.dtr.enable",
"megengine.distributed.get_rank"
] | [((565, 590), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (588, 590), False, 'import argparse\n'), ((1353, 1389), 'importlib.import_module', 'importlib.import_module', (['module_name'], {}), '(module_name)\n', (1376, 1389), False, 'import importlib\n'), ((1577, 1608), 'os.path.abspath', 'os.... |
from typing import Optional, List
from sqlmodel import SQLModel, Field, Relationship
class SongBase(SQLModel):
name: str
artist: str
year: Optional[int] = None
class Song(SongBase, table=True):
id: int = Field(primary_key=True)
class SongRead(SongBase):
id: int
class SongCreate(SongBase):
... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((224, 247), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (229, 247), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((379, 402), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (384, 402), False, 'from sqlmodel import SQLModel... |
from collections import OrderedDict
import numpy as np
import megengine.functional as F
import megengine.module as M
from megengine import Tensor
from megengine.core._imperative_rt.core2 import apply
from megengine.core.ops import builtin
from megengine.module import Module
from megengine.traced_module import TracedM... | [
"megengine.traced_module.enable_expr_checker",
"megengine.Tensor",
"megengine.module.Elemwise",
"megengine.core.ops.builtin.Elemwise",
"megengine.traced_module.trace_module"
] | [((1514, 1535), 'megengine.traced_module.enable_expr_checker', 'enable_expr_checker', ([], {}), '()\n', (1533, 1535), False, 'from megengine.traced_module import TracedModule, enable_expr_checker, trace_module\n'), ((1544, 1553), 'megengine.Tensor', 'Tensor', (['(1)'], {}), '(1)\n', (1550, 1553), False, 'from megengine... |
"""
Utility functions based on igakit.
"""
import numpy as nm
from sfepy.base.base import Struct
from sfepy.discrete.fem import Mesh
from sfepy.mesh.mesh_generators import get_tensor_product_conn
def create_linear_fe_mesh(nurbs, pars=None):
"""
Convert a NURBS object into a nD-linear tensor product FE mesh.
... | [
"sfepy.base.base.Struct",
"sfepy.discrete.fem.Mesh.from_data"
] | [((2365, 2404), 'numpy.zeros', 'nm.zeros', (['conn.shape[0]'], {'dtype': 'nm.int32'}), '(conn.shape[0], dtype=nm.int32)\n', (2373, 2404), True, 'import numpy as nm\n'), ((2416, 2478), 'sfepy.discrete.fem.Mesh.from_data', 'Mesh.from_data', (['"""nurbs"""', 'coors', 'None', '[conn]', '[mat_id]', '[desc]'], {}), "('nurbs'... |
from fastapi.encoders import jsonable_encoder
from fastapi.testclient import TestClient
from sqlmodel import Session, select
from model.item import Item
TEST_ITEM = {
"name": "aasif126",
"sku": "AASI126",
"metric": "m",
"cost": 2200
}
def test_get_items_returns_no_item_when_table_is_empty(client: Te... | [
"sqlmodel.select"
] | [((559, 576), 'model.item.Item', 'Item', ([], {}), '(**TEST_ITEM)\n', (563, 576), False, 'from model.item import Item\n'), ((1989, 2011), 'fastapi.encoders.jsonable_encoder', 'jsonable_encoder', (['item'], {}), '(item)\n', (2005, 2011), False, 'from fastapi.encoders import jsonable_encoder\n'), ((1491, 1503), 'sqlmodel... |
import uuid
from datetime import datetime, timedelta, timezone
from typing import AsyncGenerator
import pytest
from pydantic import UUID4
from sqlalchemy import exc
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.orm import sessionmaker
from sqlmodel import Session, SQLModel, creat... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.SQLModel.metadata.drop_all",
"sqlmodel.Session",
"sqlmodel.create_engine"
] | [((1537, 1859), 'pytest.fixture', 'pytest.fixture', ([], {'params': "[(init_sync_session, 'sqlite:///./test-sqlmodel-access-token.db',\n SQLModelAccessTokenDatabase, SQLModelUserDatabase), (init_async_session,\n 'sqlite+aiosqlite:///./test-sqlmodel-access-token.db',\n SQLModelAccessTokenDatabaseAsync, SQLModel... |
"""
DAG related functions.
"""
import operator
from collections import defaultdict
from io import StringIO
from typing import Any, DefaultDict, Dict, List, Optional, Set
import asciidag.graph
import asciidag.node
from sqlmodel import Session, select
from sqloxide import parse_sql
from datajunction.constants import D... | [
"sqlmodel.select"
] | [((658, 668), 'io.StringIO', 'StringIO', ([], {}), '()\n', (666, 668), False, 'from io import StringIO\n'), ((3980, 4010), 'sqloxide.parse_sql', 'parse_sql', (['sql'], {'dialect': '"""ansi"""'}), "(sql, dialect='ansi')\n", (3989, 4010), False, 'from sqloxide import parse_sql\n'), ((4324, 4340), 'collections.defaultdict... |
"""
Notes
-----
Important attributes of continuous (order > 0) :class:`Field` and
:class:`SurfaceField` instances:
- `vertex_remap` : `econn[:, :n_vertex] = vertex_remap[conn]`
- `vertex_remap_i` : `conn = vertex_remap_i[econn[:, :n_vertex]]`
where `conn` is the mesh vertex connectivity, `econn` is the
region-local ... | [
"sfepy.discrete.fem.mesh.Mesh.from_data",
"sfepy.discrete.integrals.Integral",
"sfepy.base.base.Struct",
"sfepy.discrete.fem.linearizer.get_eval_coors",
"sfepy.discrete.fem.meshio.convert_complex_output",
"sfepy.discrete.fem.linearizer.create_output",
"sfepy.discrete.fem.poly_spaces.PolySpace.any_from_a... | [((2582, 2610), 'numpy.dot', 'nm.dot', (['bf', 'mesh_coors[conn]'], {}), '(bf, mesh_coors[conn])\n', (2588, 2610), True, 'import numpy as nm\n'), ((2630, 2655), 'numpy.swapaxes', 'nm.swapaxes', (['ecoors', '(0)', '(1)'], {}), '(ecoors, 0, 1)\n', (2641, 2655), True, 'import numpy as nm\n'), ((2805, 2846), 'numpy.zeros',... |
from typing import Optional
from sqlmodel import Field, SQLModel
from pydantic import validator
from datetime import datetime
import numpy as np
class Forecast(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
user_id: int = Field(foreign_key="app_db.appuser.id")
epic_id: i... | [
"sqlmodel.Field"
] | [((210, 247), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (215, 247), False, 'from sqlmodel import Field, SQLModel\n'), ((267, 305), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""app_db.appuser.id"""'}), "(foreign_key='app_db.appuser.id')\n"... |
from typing import Optional
import strawberry
from sqlmodel import (
SQLModel,
Field,
create_engine,
select,
Session
)
engine = create_engine('sqlite:///database.db')
class Person(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
nome: str
idade: int
... | [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.select"
] | [((150, 188), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite:///database.db"""'], {}), "('sqlite:///database.db')\n", (163, 188), False, 'from sqlmodel import SQLModel, Field, create_engine, select, Session\n'), ((320, 356), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], ... |
# 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"
] | [((2960, 3025), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""mode"""', "['normal', 'group', 'transpose']"], {}), "('mode', ['normal', 'group', 'transpose'])\n", (2983, 3025), False, 'import pytest\n'), ((4527, 4573), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""mode"""', '[True, False]'], ... |
import streamlit as st
import pandas as pd
import argparse
import datetime as dt
from sqlmodel import create_engine, Session
parser = argparse.ArgumentParser(description="A steamlit dashboard for visualising news analytics.")
parser.add_argument("--database", type=str, default="sqlite:///database.db")
class Dasboard:... | [
"sqlmodel.create_engine",
"sqlmodel.Session"
] | [((135, 231), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""A steamlit dashboard for visualising news analytics."""'}), "(description=\n 'A steamlit dashboard for visualising news analytics.')\n", (158, 231), False, 'import argparse\n'), ((385, 408), 'sqlmodel.create_engine', 'create... |
"""
Explicit time stepping solvers for use with DG FEM
"""
import numpy as nm
import numpy.linalg as nla
# sfepy imports
from sfepy.base.base import get_default, output
from sfepy.solvers import TimeSteppingSolver
from sfepy.solvers.solvers import SolverMeta
from sfepy.solvers.ts import TimeStepper
from sfepy.solvers.... | [
"sfepy.base.base.get_default",
"sfepy.solvers.TimeSteppingSolver.__init__",
"sfepy.base.base.output",
"sfepy.solvers.ts.TimeStepper.from_conf"
] | [((1340, 1415), 'sfepy.solvers.TimeSteppingSolver.__init__', 'TimeSteppingSolver.__init__', (['self', 'conf'], {'nls': 'nls', 'context': 'context'}), '(self, conf, nls=nls, context=context, **kwargs)\n', (1367, 1415), False, 'from sfepy.solvers import TimeSteppingSolver\n'), ((1470, 1502), 'sfepy.solvers.ts.TimeStepper... |
import pytest
from fastapi.testclient import TestClient
from sqlmodel import Session, SQLModel, create_engine
from sqlmodel.pool import StaticPool
from .main import Hero, app, get_session
@pytest.fixture(name="session")
def session_fixture():
engine = create_engine(
"sqlite://", connect_args={"check_same... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.create_engine"
] | [((192, 222), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""session"""'}), "(name='session')\n", (206, 222), False, 'import pytest\n'), ((468, 497), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""client"""'}), "(name='client')\n", (482, 497), False, 'import pytest\n'), ((259, 354), 'sqlmodel.create_engin... |
import types
from dataclasses import dataclass
from typing import Callable, List, Union
from fastapi import Depends, FastAPI, HTTPException, Query
from sqlmodel import Field, Session, SQLModel, select
# Model generator + container -------------------------------------------------------------
@dataclass
class Multi... | [
"sqlmodel.select",
"sqlmodel.Field"
] | [((5955, 5982), 'fastapi.Query', 'Query', ([], {'default': '(100)', 'lte': '(100)'}), '(default=100, lte=100)\n', (5960, 5982), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((7999, 8026), 'fastapi.Query', 'Query', ([], {'default': '(100)', 'lte': '(100)'}), '(default=100, lte=100)\n', (8004, ... |
import numpy as nm
from sfepy.mechanics.matcoefs import stiffness_from_youngpoisson
from sfepy.discrete.fem.meshio import UserMeshIO
from sfepy.mesh.mesh_generators import gen_block_mesh
from sfepy import data_dir
def mesh_hook(mesh, mode):
if mode == 'read':
mesh = gen_block_mesh([0.0098, 0.0011, 0.1], [... | [
"sfepy.discrete.fem.meshio.UserMeshIO",
"sfepy.mesh.mesh_generators.gen_block_mesh",
"sfepy.mechanics.matcoefs.stiffness_from_youngpoisson"
] | [((1406, 1427), 'sfepy.discrete.fem.meshio.UserMeshIO', 'UserMeshIO', (['mesh_hook'], {}), '(mesh_hook)\n', (1416, 1427), False, 'from sfepy.discrete.fem.meshio import UserMeshIO\n'), ((281, 381), 'sfepy.mesh.mesh_generators.gen_block_mesh', 'gen_block_mesh', (['[0.0098, 0.0011, 0.1]', '[5, 3, 17]', '[0, 0, 0.05]'], {'... |
import os
import pytest
import time
from fastapi.testclient import TestClient
from sqlmodel import Session, create_engine
from main import app
from database import get_db
from settings import Settings
from alembic.command import upgrade, downgrade
from alembic.config import Config
@pytest.fixture(autouse=True)
def sl... | [
"sqlmodel.create_engine",
"sqlmodel.Session"
] | [((285, 313), 'pytest.fixture', 'pytest.fixture', ([], {'autouse': '(True)'}), '(autouse=True)\n', (299, 313), False, 'import pytest\n'), ((368, 399), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (382, 399), False, 'import pytest\n'), ((530, 560), 'pytest.fixture', 'pytes... |
from typing import AsyncGenerator, Generator
from aiobotocore.client import AioBaseClient
from aiobotocore.session import get_session
from sqlmodel import Session
from sqlmodel.ext.asyncio.session import AsyncSession
from ..core.config import settings
from ..db.db import engine, engine_async
async def get_s3() -> A... | [
"sqlmodel.ext.asyncio.session.AsyncSession",
"sqlmodel.Session"
] | [((370, 383), 'aiobotocore.session.get_session', 'get_session', ([], {}), '()\n', (381, 383), False, 'from aiobotocore.session import get_session\n'), ((777, 803), 'sqlmodel.ext.asyncio.session.AsyncSession', 'AsyncSession', (['engine_async'], {}), '(engine_async)\n', (789, 803), False, 'from sqlmodel.ext.asyncio.sessi... |
"""
Functions to visualize quadrature points in reference elements.
"""
import numpy as nm
import matplotlib.pyplot as plt
from sfepy.base.base import output
from sfepy.postprocess.plot_dofs import _get_axes, _to2d
from sfepy.postprocess.plot_facets import plot_geometry
def _get_qp(geometry, order):
from sfepy.d... | [
"sfepy.postprocess.plot_dofs._to2d",
"sfepy.discrete.fem.geometry_element.GeometryElement",
"sfepy.base.base.output",
"sfepy.postprocess.plot_dofs._get_axes",
"sfepy.discrete.fem.Mesh.from_data",
"sfepy.discrete.Integral",
"sfepy.discrete.fem.Field.from_args",
"sfepy.postprocess.plot_facets.plot_geome... | [((423, 451), 'sfepy.discrete.Integral', 'Integral', (['"""aux"""'], {'order': 'order'}), "('aux', order=order)\n", (431, 451), False, 'from sfepy.discrete import Integral\n'), ((540, 650), 'sfepy.base.base.output', 'output', (['"""geometry:"""', 'geometry', '"""order:"""', 'order', '"""num. points:"""', 'coors.shape[0... |
from fastapi import Depends, Response
from fastapi.routing import APIRouter
from pydantic import BaseModel # pylint: disable=E0611
from sqlmodel import Session, select
from starlette.responses import JSONResponse
from fastapi_server.database.database import get_session
from fastapi_server.models.user import User
log... | [
"sqlmodel.select"
] | [((332, 343), 'fastapi.routing.APIRouter', 'APIRouter', ([], {}), '()\n', (341, 343), False, 'from fastapi.routing import APIRouter\n'), ((590, 610), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (597, 610), False, 'from fastapi import Depends, Response\n'), ((994, 1023), 'starlette.responses.... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Dec 28 09:33:53 2020
@author: dhulls
"""
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, St... | [
"sfepy.discrete.Equations",
"sfepy.discrete.conditions.EssentialBC",
"sfepy.solvers.ls.ScipyDirect",
"sfepy.discrete.Equation",
"sfepy.solvers.nls.Newton",
"sfepy.discrete.conditions.Conditions",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.Integral",
"sfepy.discrete.fem.Field.from_args",
... | [((253, 273), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (268, 273), False, 'import sys\n'), ((912, 928), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (926, 928), False, 'from argparse import ArgumentParser\n'), ((1183, 1237), 'sfepy.discrete.fem.Mesh.from_file', 'Mesh.from_fi... |
"""
Nonlinear solvers.
"""
import time
import numpy as nm
import numpy.linalg as nla
from sfepy.base.base import output, get_default, debug, Struct
from sfepy.base.log import Log, get_logging_conf
from sfepy.solvers.solvers import SolverMeta, NonlinearSolver
def check_tangent_matrix(conf, vec_x0, fun, fun_grad):
... | [
"sfepy.base.log.get_logging_conf",
"sfepy.base.base.get_default",
"sfepy.solvers.solvers.NonlinearSolver.__init__",
"sfepy.base.base.Struct",
"sfepy.base.plotutils.plot_matrix_diff",
"sfepy.base.log.Log",
"sfepy.base.base.debug",
"sfepy.base.base.output"
] | [((772, 792), 'numpy.zeros_like', 'nm.zeros_like', (['vec_r'], {}), '(vec_r)\n', (785, 792), True, 'import numpy as nm\n'), ((1258, 1270), 'time.clock', 'time.clock', ([], {}), '()\n', (1268, 1270), False, 'import time\n'), ((1275, 1305), 'sfepy.base.base.output', 'output', (['mtx_a', '""".. analytical"""'], {}), "(mtx... |
from typing import List, Dict
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlmodel import Session, select
from app import models
from app.api import deps
router = APIRouter()
@router.post("/", response_model=models.TeamRead)
def create_team(
*, session: Session = Depends(de... | [
"sqlmodel.select"
] | [((198, 209), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (207, 209), False, 'from fastapi import APIRouter, Depends, HTTPException, Query\n'), ((310, 335), 'fastapi.Depends', 'Depends', (['deps.get_session'], {}), '(deps.get_session)\n', (317, 335), False, 'from fastapi import APIRouter, Depends, HTTPException... |
from minio import Minio
import os
from typing import Optional
from glob import glob
import pathlib
from sqlmodel import Field, Session, SQLModel, create_engine
def get_images(folder:str="../cls_labeling/public/images"):
return glob(str(pathlib.Path(folder,"**","*.jpg")), recursive=True)
class Image(SQLModel, tab... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.Field",
"sqlmodel.create_engine"
] | [((355, 392), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (360, 392), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((489, 524), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite:///image.db"""'], {}), "('sqlite:/... |
#!/usr/bin/env mdl
# This file will seal the nms opr within a better way than lib_nms
import ctypes
import os
import struct
import numpy as np
import megengine as mge
import megengine.functional as F
from megengine._internal.craniotome import CraniotomeBase
from megengine.core.tensor import wrap_io_tensor
_current_p... | [
"megengine.tensor"
] | [((380, 421), 'os.path.join', 'os.path.join', (['_current_path', '"""lib_nms.so"""'], {}), "(_current_path, 'lib_nms.so')\n", (392, 421), False, 'import os\n'), ((342, 367), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (357, 367), False, 'import os\n'), ((441, 462), 'ctypes.CDLL', 'ctypes.C... |
from __future__ import absolute_import
import numpy as nm
from sfepy.base.base import assert_
from sfepy.linalg import norm_l2_along_axis as norm
from sfepy.linalg import dot_sequences, insert_strided_axis
from sfepy.discrete.fem.poly_spaces import PolySpace
from sfepy.discrete.fem.mappings import VolumeMapping
from s... | [
"sfepy.linalg.norm_l2_along_axis",
"sfepy.discrete.fem.poly_spaces.PolySpace.any_from_args",
"sfepy.mechanics.tensors.dim2sym",
"sfepy.linalg.insert_strided_axis",
"sfepy.linalg.dot_sequences",
"sfepy.discrete.fem.mappings.VolumeMapping"
] | [((1263, 1279), 'numpy.cross', 'nm.cross', (['t1', 't2'], {}), '(t1, t2)\n', (1271, 1279), True, 'import numpy as nm\n'), ((1289, 1304), 'numpy.cross', 'nm.cross', (['n', 't1'], {}), '(n, t1)\n', (1297, 1304), True, 'import numpy as nm\n'), ((1466, 1537), 'numpy.concatenate', 'nm.concatenate', (['(t1[:, :, None], t2[:,... |
# -*- 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 ARRANTIE... | [
"megengine.functional.argmax",
"megengine.functional.flatten",
"megengine.module.init.fill_",
"megengine.functional.indexing_one_hot",
"megengine.functional.softmax",
"megengine.functional.minimum",
"megengine.module.init.normal_",
"megengine.functional.add_axis",
"megengine.module.Linear",
"megen... | [((636, 688), 'official.vision.detection.layers.BoxCoder', 'layers.BoxCoder', (['cfg.rcnn_reg_mean', 'cfg.rcnn_reg_std'], {}), '(cfg.rcnn_reg_mean, cfg.rcnn_reg_std)\n', (651, 688), False, 'from official.vision.detection import layers\n'), ((909, 974), 'megengine.module.Linear', 'M.Linear', (['(256 * self.pooling_size[... |
# -*- coding: utf-8 -*-
# This repo 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 ... | [
"megengine.save",
"megengine.load"
] | [((1472, 1503), 'collections.defaultdict', 'defaultdict', (['utils.AverageMeter'], {}), '(utils.AverageMeter)\n', (1483, 1503), False, 'from collections import defaultdict\n'), ((1555, 1586), 'collections.defaultdict', 'defaultdict', (['utils.AverageMeter'], {}), '(utils.AverageMeter)\n', (1566, 1586), False, 'from col... |
import asyncio
import logging
import os
import time
from datetime import datetime
from sqlmodel import Session, SQLModel, select
from starlette.concurrency import run_in_threadpool
from ..datatypes import ArtmuseumTimeLabel
from ..scraping.artmuseum import scrap_artmuseum
from ..scraping.philharmonia import scrap_phi... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.select"
] | [((1043, 1092), 'logging.info', 'logging.info', (['"""Started scraping up-to-date info."""'], {}), "('Started scraping up-to-date info.')\n", (1055, 1092), False, 'import logging\n'), ((1432, 1482), 'logging.info', 'logging.info', (['"""Finished scraping up-to-date info."""'], {}), "('Finished scraping up-to-date info.... |
from typing import Union
from fastapi import FastAPI
from pydantic import BaseSettings
from ...utils import get_settings
try:
from sqlalchemy.engine import Engine
from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
from sqlmodel import Session, SQLModel, create_engine
from sqlmodel.ex... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.create_engine",
"sqlmodel.ext.asyncio.session.AsyncSession"
] | [((1723, 1761), 'sqlalchemy.ext.asyncio.create_async_engine', 'create_async_engine', (['db_uri'], {}), '(db_uri, **options)\n', (1742, 1761), False, 'from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine\n'), ((1789, 1821), 'sqlmodel.create_engine', 'create_engine', (['db_uri'], {}), '(db_uri, **options)\... |
from http import HTTPStatus
from typing import List
from fastapi import APIRouter, Depends
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.future import select
from sqlmodel import select
from starlette.responses import Response
from icon_governance.db import get_session
from icon_governance.models.pr... | [
"sqlmodel.select"
] | [((346, 357), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (355, 357), False, 'from fastapi import APIRouter, Depends\n'), ((431, 451), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (438, 451), False, 'from fastapi import APIRouter, Depends\n'), ((780, 800), 'fastapi.Depends', 'Depends'... |
"""
Utility functions.
"""
import logging
import os
from functools import lru_cache
from pathlib import Path
from typing import Iterator, List, Optional
from dotenv import load_dotenv
from rich.logging import RichHandler
from sqlalchemy.engine import Engine
from sqlmodel import Session, SQLModel, create_engine
from y... | [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all"
] | [((1186, 1223), 'os.environ.get', 'os.environ.get', (['"""DOTENV_FILE"""', '""".env"""'], {}), "('DOTENV_FILE', '.env')\n", (1200, 1223), False, 'import os\n'), ((1228, 1252), 'dotenv.load_dotenv', 'load_dotenv', (['dotenv_file'], {}), '(dotenv_file)\n', (1239, 1252), False, 'from dotenv import load_dotenv\n'), ((1264,... |
from typing import Any, Dict, List
from uuid import UUID
from sqlalchemy.orm import selectinload
from sqlmodel import select
from sqlmodel.ext.asyncio.session import AsyncSession
from service.crud.base import CRUDBase, ModelType
from service.models.models import Topic, TopicBase, TopicCreate, TopicModel, Word
clas... | [
"sqlmodel.select"
] | [((805, 839), 'sqlalchemy.orm.selectinload', 'selectinload', (['self.model.top_words'], {}), '(self.model.top_words)\n', (817, 839), False, 'from sqlalchemy.orm import selectinload\n'), ((1115, 1175), 'service.models.models.TopicCreate.parse_obj', 'TopicCreate.parse_obj', (["{**topic, 'topic_model_id': model.id}"], {})... |
from datetime import date
from typing import List
from sqlmodel import select
from config.config_utils import get_managed_teams_config
from src.api.fixtures_client import FixturesClient
from src.db.db_manager import NotifierDBManager
from src.db.notif_sql_models import Fixture as DBFixture
from src.db.notif_sql_model... | [
"sqlmodel.select"
] | [((534, 553), 'src.db.db_manager.NotifierDBManager', 'NotifierDBManager', ([], {}), '()\n', (551, 553), False, 'from src.db.db_manager import NotifierDBManager\n'), ((3634, 3660), 'config.config_utils.get_managed_teams_config', 'get_managed_teams_config', ([], {}), '()\n', (3658, 3660), False, 'from config.config_utils... |
# -*- 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.data.transform.ToMode",
"megengine.amp.autocast",
"megengine.device.set_prealloc_config",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.get_logger",
"megengine.distributed.make_allreduce_cb",
"megengine.data.transform.RandomHorizontalFlip",
"megengin... | [((942, 966), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (956, 966), True, 'import megengine as mge\n'), ((991, 1057), 'megengine.device.set_prealloc_config', 'mge.device.set_prealloc_config', (['(1024)', '(1024)', '(512 * 1024 * 1024)', '(2.0)'], {}), '(1024, 1024, 512 * 1024 * 1024,... |
# -*- 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.test.assertTensorClose",
"megengine.graph.compile",
"megengine.module.init.calculate_fan_in_and_fan_out",
"megengine.module.Linear",
"megengine.module.init.zeros_",
"megengine.functional.cross_entropy_with_softmax",
"megengine.functional.relu"
] | [((3348, 3387), 'megengine.functional.cross_entropy_with_softmax', 'cross_entropy_with_softmax', (['pred', 'label'], {}), '(pred, label)\n', (3374, 3387), False, 'from megengine.functional import cross_entropy_with_softmax, relu\n'), ((3448, 3478), 'megengine.graph.compile', 'mge.graph.compile', (['loss', 'grads'], {})... |
"""Movie models."""
import datetime
import typing
import pydantic
import sqlmodel
from app.models import mixins
from app.models import validators
if typing.TYPE_CHECKING:
from app.models.patron import Patron, PatronRead
class MovieBase(sqlmodel.SQLModel, mixins.ProposalMixin, mixins.LinksMixin):
"""Base M... | [
"sqlmodel.Relationship"
] | [((941, 1037), 'sqlmodel.Relationship', 'sqlmodel.Relationship', ([], {'back_populates': '"""movies"""', 'sa_relationship_kwargs': "{'lazy': 'selectin'}"}), "(back_populates='movies', sa_relationship_kwargs={\n 'lazy': 'selectin'})\n", (962, 1037), False, 'import sqlmodel\n'), ((529, 603), 'pydantic.validator', 'pyd... |
from datetime import datetime
from typing import TYPE_CHECKING, Dict, List, Optional
from pydantic import root_validator
from sqlalchemy import Column
from sqlmodel import Field, Relationship, SQLModel
from .event_attendance import EventAttendance
from .types import TimeStamp
if TYPE_CHECKING:
from .feedback imp... | [
"sqlmodel.Field",
"sqlmodel.Relationship"
] | [((838, 873), 'sqlmodel.Field', 'Field', ([], {'default': '(True)', 'nullable': '(False)'}), '(default=True, nullable=False)\n', (843, 873), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((880, 896), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (894, 896), False, 'from pydantic impor... |
"""Initial
Revision ID: ec941f1f8242
Revises: <PASSWORD>
Create Date: 2021-10-10 18:34:18.294594
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = '<KEY>'
down_revision = 'd<PASSWORD>'
branch_labels = None
depends_on = None
def upgrade():
# ... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((726, 773), 'alembic.op.drop_index', 'op.drop_index', (['"""ix_hero_age"""'], {'table_name': '"""hero"""'}), "('ix_hero_age', table_name='hero')\n", (739, 773), False, 'from alembic import op\n'), ((778, 824), 'alembic.op.drop_index', 'op.drop_index', (['"""ix_hero_id"""'], {'table_name': '"""hero"""'}), "('ix_hero_i... |
import functools
import numpy as np
import pytest
import megengine
from megengine.autodiff.grad_manager import GradManager
from megengine.core.ops.builtin import GetVarShape, Reduce, TypeCvt
from megengine.core.tensor.utils import subgraph_fn
from megengine.device import CompNode, get_default_device
from megengine.ji... | [
"megengine.core.ops.builtin.GetVarShape",
"megengine.tensor",
"megengine.device.CompNode",
"megengine.Tensor",
"megengine.device.get_default_device",
"megengine.jit.trace",
"megengine.core.tensor.utils.subgraph_fn",
"megengine.autodiff.grad_manager.GradManager",
"megengine.core.ops.builtin.Reduce",
... | [((355, 424), 'functools.partial', 'functools.partial', (['np.testing.assert_allclose'], {'atol': '(5e-06)', 'rtol': '(5e-06)'}), '(np.testing.assert_allclose, atol=5e-06, rtol=5e-06)\n', (372, 424), False, 'import functools\n'), ((426, 459), 'functools.lru_cache', 'functools.lru_cache', ([], {'maxsize': 'None'}), '(ma... |
"""
Linearization of higher order solutions for the purposes of visualization.
"""
from __future__ import absolute_import
import numpy as nm
from sfepy.linalg import dot_sequences
from sfepy.discrete.fem.refine import refine_reference
from six.moves import range
def get_eval_dofs(dofs, dof_conn, ps, ori=None):
""... | [
"sfepy.linalg.dot_sequences",
"sfepy.discrete.fem.refine.refine_reference"
] | [((2121, 2153), 'sfepy.discrete.fem.refine.refine_reference', 'refine_reference', (['ps.geometry', '(1)'], {}), '(ps.geometry, 1)\n', (2137, 2153), False, 'from sfepy.discrete.fem.refine import refine_reference\n'), ((2207, 2222), 'numpy.arange', 'nm.arange', (['n_el'], {}), '(n_el)\n', (2216, 2222), True, 'import nump... |
# -*- coding: utf-8 -*-
# @Time : 2022/1/2 17:50
# @Author : WhaleFall
# @Site :
# @File : __init__.py.py
# @Software: PyCharm
# Flask 应用初始化,工厂函数
from flask import Flask
from flask_login import LoginManager
from config import config
from sqlmodel import create_engine,SQLModel
# 实例化一个登录组件
login_manager = LoginManager(... | [
"sqlmodel.create_engine"
] | [((307, 321), 'flask_login.LoginManager', 'LoginManager', ([], {}), '()\n', (319, 321), False, 'from flask_login import LoginManager\n'), ((518, 533), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (523, 533), False, 'from flask import Flask\n'), ((770, 839), 'sqlmodel.create_engine', 'create_engine', (['c... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.