code stringlengths 110 64.5k | apis list | extract_api stringlengths 123 69.9k |
|---|---|---|
import os.path as op
import numpy as nm
import sfepy
from sfepy.discrete.common import Field
import sfepy.discrete.common.global_interp as gi
from sfepy.base.testing import TestCommon
class Test(TestCommon):
@staticmethod
def from_conf(conf, options):
test = Test(conf=conf, options=options)
... | [
"sfepy.discrete.common.Field.from_args",
"sfepy.discrete.common.global_interp.get_ref_coors",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.fem.FEDomain"
] | [((438, 513), 'sfepy.discrete.fem.Mesh.from_file', 'Mesh.from_file', (['"""meshes/3d/special/cross3d.mesh"""'], {'prefix_dir': 'sfepy.data_dir'}), "('meshes/3d/special/cross3d.mesh', prefix_dir=sfepy.data_dir)\n", (452, 513), False, 'from sfepy.discrete.fem import Mesh, FEDomain\n'), ((561, 585), 'sfepy.discrete.fem.FE... |
#!/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 SE, DropPath, conv2d, gap2d, linear, norm2d, pool2d
@pytest.mark.parametrize("w_in", [4])
@pytest.mark.parametrize("w_out"... | [
"megengine.random.normal",
"megengine.Tensor"
] | [((251, 287), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[4]'], {}), "('w_in', [4])\n", (274, 287), False, 'import pytest\n'), ((289, 326), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_out"""', '[8]'], {}), "('w_out', [8])\n", (312, 326), False, 'import pytest\n'), ((328, 36... |
import numpy as nm
from sfepy.base.base import Struct
class SplineBox(Struct):
"""
B-spline geometry parametrization. Geometry can be modified
by moving spline control points.
"""
@staticmethod
def mmax(x, y):
n = len(x)
aux = nm.zeros((2,n), dtype=nm.int)
aux[0,:] = x[... | [
"sfepy.base.base.Struct.__init__"
] | [((269, 299), 'numpy.zeros', 'nm.zeros', (['(2, n)'], {'dtype': 'nm.int'}), '((2, n), dtype=nm.int)\n', (277, 299), True, 'import numpy as nm\n'), ((376, 395), 'numpy.max', 'nm.max', (['aux'], {'axis': '(0)'}), '(aux, axis=0)\n', (382, 395), True, 'import numpy as nm\n'), ((536, 573), 'numpy.zeros', 'nm.zeros', (['(n1 ... |
from __future__ import absolute_import
import os.path as op
import numpy as nm
from sfepy import data_dir
from sfepy.base.testing import TestCommon
import six
def init_vec(variables):
return nm.random.rand(variables.di.ptr[-1])
def check_vec(self, vec, ii, ok, conds, variables):
from sfepy.discrete.common.... | [
"sfepy.discrete.Equation",
"sfepy.discrete.conditions.PeriodicBC",
"sfepy.discrete.conditions.EssentialBC",
"sfepy.discrete.fem.periodic.match_y_line",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.common.dof_info.expand_nodes_to_equations",
"sfepy.discrete.fem.Field.from_args",
"sfepy.discrete... | [((199, 235), 'numpy.random.rand', 'nm.random.rand', (['variables.di.ptr[-1]'], {}), '(variables.di.ptr[-1])\n', (213, 235), True, 'import numpy as nm\n'), ((1632, 1692), 'sfepy.discrete.fem.Mesh.from_file', 'Mesh.from_file', (["(data_dir + '/meshes/2d/square_unit_tri.mesh')"], {}), "(data_dir + '/meshes/2d/square_unit... |
from time import sleep
from sqlmodel import select
from icon_governance.config import settings
from icon_governance.log import logger
from icon_governance.models.preps import Prep
from icon_governance.utils.rpc import (
convert_hex_int,
get_preps_cps,
get_sponsors_record,
post_rpc_json,
)
def get_cp... | [
"sqlmodel.select"
] | [((361, 382), 'icon_governance.utils.rpc.get_sponsors_record', 'get_sponsors_record', ([], {}), '()\n', (380, 382), False, 'from icon_governance.utils.rpc import convert_hex_int, get_preps_cps, get_sponsors_record, post_rpc_json\n'), ((418, 460), 'icon_governance.log.logger.info', 'logger.info', (['"""No sponsors found... |
from typing import List, Optional
from fastapi import Depends, FastAPI, HTTPException, Query
from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select
class TeamBase(SQLModel):
name: str = Field(index=True)
headquarters: str
class Team(TeamBase, table=True):
id: Optional[int] =... | [
"sqlmodel.Relationship",
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.select"
] | [((1384, 1447), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)', 'connect_args': 'connect_args'}), '(sqlite_url, echo=True, connect_args=connect_args)\n', (1397, 1447), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((1607, 1616), 'fastapi.F... |
import os.path as op
from sfepy.base.base import *
from sfepy.base.conf import transform_variables, transform_fields
from sfepy.base.testing import TestCommon
variables = {
'u' : ('unknown field', 'f', 0),
'v' : ('test field', 'f', 'u'),
}
def in_dir(adir):
return lambda x: op.join(adir, x... | [
"sfepy.fem.Domain",
"sfepy.base.conf.transform_variables",
"sfepy.linalg.make_axis_rotation_matrix",
"sfepy.fem.Mesh",
"sfepy.fem.Field"
] | [((669, 685), 'sfepy.fem.Domain', 'Domain', (['"""d1"""', 'm1'], {}), "('d1', m1)\n", (675, 685), False, 'from sfepy.fem import Mesh, Domain, Field, Variables\n'), ((775, 840), 'sfepy.fem.Field', 'Field', (['"""f"""', 'nm.float64', 'f[0]', 'd1.regions[f[1]]'], {'approx_order': 'f[2]'}), "('f', nm.float64, f[0], d1.regi... |
"""
dayong.models
~~~~~~~~~~~~~
A model maps to a single database table. It contains fields and behaviors of the data
stored in the database.
"""
from typing import Optional
from sqlmodel import Field, SQLModel
class Message(SQLModel):
"""Base model class for message table models."""
message_id: str
clas... | [
"sqlmodel.Field"
] | [((610, 647), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (615, 647), False, 'from sqlmodel import Field, SQLModel\n')] |
import typing as t
if t.TYPE_CHECKING:
from ..core.discussions import DB_Discussion
from ..core.users import DB_User
from datetime import datetime
from sqlmodel import SQLModel, Field, Relationship
class DB_TagUser(SQLModel, table=True):
"""
Represents a tag-to-user relationship in the databas... | [
"sqlmodel.Field",
"sqlmodel.Relationship"
] | [((394, 455), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)', 'foreign_key': '"""users.id"""'}), "(default=None, primary_key=True, foreign_key='users.id')\n", (399, 455), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((516, 576), 'sqlmodel.Field', 'Field', ([], {'default':... |
from typing import Optional, List
from pydantic import BaseModel, validator, ValidationError
from sqlmodel import SQLModel, Field
class User(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
username: str = Field(nullable=False, sa_column_kwargs={"unique": True})
superuser: ... | [
"sqlmodel.Field"
] | [((190, 227), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (195, 227), False, 'from sqlmodel import SQLModel, Field\n'), ((248, 304), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'sa_column_kwargs': "{'unique': True}"}), "(nullable=False... |
from pathlib import Path
from typing import List
import nonebot
import pytest
from nonebug import App
from .utils import make_fake_event, make_fake_message
@pytest.mark.asyncio
async def test_db(app: App):
"""测试数据库"""
from sqlmodel import select
from nonebot_plugin_datastore.db import create_session, i... | [
"sqlmodel.select"
] | [((372, 408), 'nonebot.load_plugin', 'nonebot.load_plugin', (['"""tests.example"""'], {}), "('tests.example')\n", (391, 408), False, 'import nonebot\n'), ((1667, 1714), 'nonebot.load_plugin', 'nonebot.load_plugin', (['"""nonebot_plugin_datastore"""'], {}), "('nonebot_plugin_datastore')\n", (1686, 1714), False, 'import ... |
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
from typing import List, Optional
from sqlmodel import SQLModel, Field, Relationship, VARCHAR, Column
from pydantic import EmailStr
... | [
"sqlmodel.Relationship",
"sqlmodel.Field",
"sqlmodel.Column"
] | [((374, 411), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (379, 411), False, 'from sqlmodel import SQLModel, Field, Relationship, VARCHAR, Column\n'), ((453, 489), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""group"""'}), "... |
from typing import List, Union
from fastapi import APIRouter, Request
from fastapi.exceptions import HTTPException
from sqlmodel import Session, or_, select
from ..db import ActiveSession
from ..security import (
AdminUser,
AuthenticatedUser,
HashedPassword,
User,
UserCreate,
UserPasswordPatch... | [
"sqlmodel.select",
"sqlmodel.or_"
] | [((374, 385), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (383, 385), False, 'from fastapi import APIRouter, Request\n'), ((1229, 1284), 'fastapi.exceptions.HTTPException', 'HTTPException', ([], {'status_code': '(404)', 'detail': '"""User not found"""'}), "(status_code=404, detail='User not found')\n", (1242, 1... |
from fastapi import FastAPI
from api import router
from settings.datastore import dbengine
from sqlmodel import SQLModel
app = FastAPI()
#include app api routers
router.add_routers(app)
SQLModel.metadata.create_all(dbengine)
@app.get("/")
def main():
return {
"message": "Welcome to pilot"
} | [
"sqlmodel.SQLModel.metadata.create_all"
] | [((127, 136), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (134, 136), False, 'from fastapi import FastAPI\n'), ((162, 185), 'api.router.add_routers', 'router.add_routers', (['app'], {}), '(app)\n', (180, 185), False, 'from api import router\n'), ((186, 224), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metada... |
# MegFlow is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2019-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 ARRANTIES OR CONDITIONS OF ANY KI... | [
"megengine.load"
] | [((778, 799), 'megengine.load', 'mge.load', (['sys.argv[1]'], {}), '(sys.argv[1])\n', (786, 799), True, 'import megengine as mge\n'), ((918, 941), 'loguru.logger.info', 'logger.info', (['f"""{feat1}"""'], {}), "(f'{feat1}')\n", (929, 941), False, 'from loguru import logger\n'), ((999, 1022), 'loguru.logger.info', 'logg... |
# -*- 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.conv3d",
"megengine.functional.pixel_shuffle",
"megengine.core.tensor.dtype.convert_to_qint32",
"megengine.config._override",
"megengine.functional.argmax",
"megengine.functional.adaptive_avg_pool2d",
"megengine.functional.argmin",
"megengine.jit.trace",
"megengine.functional.u... | [((6039, 6149), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""shape_a, shape_b"""', '[((0,), (0,)), ((10, 0), (0, 10)), ((3, 10, 0), (3, 0, 10))]'], {}), "('shape_a, shape_b', [((0,), (0,)), ((10, 0), (0, 10\n )), ((3, 10, 0), (3, 0, 10))])\n", (6062, 6149), False, 'import pytest\n'), ((6154, 6213), 'p... |
from __future__ import absolute_import
import numpy as nm
from sfepy.base.base import load_classes, Struct
from sfepy import get_paths
def transform_basis(transform, bf):
"""
Transform a basis `bf` using `transform` array of matrices.
"""
if bf.ndim == 3:
nbf = nm.einsum('cij,qdj->cqdi', trans... | [
"sfepy.base.base.load_classes",
"sfepy.get_paths"
] | [((678, 703), 'numpy.ascontiguousarray', 'nm.ascontiguousarray', (['nbf'], {}), '(nbf)\n', (698, 703), True, 'import numpy as nm\n'), ((288, 340), 'numpy.einsum', 'nm.einsum', (['"""cij,qdj->cqdi"""', 'transform', 'bf'], {'order': '"""C"""'}), "('cij,qdj->cqdi', transform, bf, order='C')\n", (297, 340), True, 'import n... |
r"""
Incompressible Stokes flow with Navier (slip) boundary conditions, flow driven
by a moving wall and a small diffusion for stabilization.
This example demonstrates the use of `no-penetration` boundary conditions as
well as `edge direction` boundary conditions together with Navier or slip
boundary conditions.
Find... | [
"sfepy.mesh.mesh_generators.gen_block_mesh",
"sfepy.discrete.fem.meshio.UserMeshIO",
"sfepy.homogenization.utils.define_box_regions"
] | [((1872, 1893), 'numpy.array', 'nm.array', (['[3, 1, 0.5]'], {}), '([3, 1, 0.5])\n', (1880, 1893), True, 'import numpy as nm\n'), ((2256, 2277), 'sfepy.discrete.fem.meshio.UserMeshIO', 'UserMeshIO', (['mesh_hook'], {}), '(mesh_hook)\n', (2266, 2277), False, 'from sfepy.discrete.fem.meshio import UserMeshIO\n'), ((2289,... |
# AtrialFibrePlugin
# Copyright (C) 2018 <NAME>, King's College London, all rights reserved, see LICENSE file
'''
Atrial fibre generation plugin.
'''
import os
import stat
import ast
import shutil
import datetime
import zipfile
import warnings
from itertools import starmap
from collections import defaultdict
try:
... | [
"sfepy.base.base.output.set_output",
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.applications.solve_pde"
] | [((1102, 1149), 'os.path.join', 'os.path.join', (['plugindir', '"""AtrialFibrePlugin.ui"""'], {}), "(plugindir, 'AtrialFibrePlugin.ui')\n", (1114, 1149), False, 'import os\n'), ((1160, 1200), 'os.path.join', 'os.path.join', (['plugindir', '"""deformetricaC"""'], {}), "(plugindir, 'deformetricaC')\n", (1172, 1200), Fals... |
from __future__ import absolute_import
from copy import copy
import numpy as nm
from sfepy.base.testing import TestCommon
from sfepy.base.base import ordered_iteritems
from sfepy import data_dir
filename_meshes = [data_dir + '/meshes/elements/%s_2.mesh' % geom
for geom in ['1_2', '2_3', '2_4', '3_... | [
"sfepy.discrete.Variables",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.Integral",
"sfepy.discrete.fem.Field.from_args",
"sfepy.base.base.ordered_iteritems",
"sfepy.terms.Term.new",
"sfepy.solvers.ts.TimeStepper",
"sfepy.discrete.FieldVariable",
"sfepy.mechanics.tensors.dim2sym",
"sfepy.d... | [((801, 813), 'sfepy.mechanics.tensors.dim2sym', 'dim2sym', (['dim'], {}), '(dim)\n', (808, 813), False, 'from sfepy.mechanics.tensors import dim2sym\n'), ((4849, 4869), 'sfepy.discrete.Materials', 'Materials', (['materials'], {}), '(materials)\n', (4858, 4869), False, 'from sfepy.discrete import FieldVariable, Materia... |
from sqlmodel import create_engine
engine = create_engine("sqlite:///database.db")
del create_engine
from .models import DuelData
from .session import Session, SessionManager
| [
"sqlmodel.create_engine"
] | [((45, 83), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite:///database.db"""'], {}), "('sqlite:///database.db')\n", (58, 83), False, 'from sqlmodel import create_engine\n')] |
import megengine as mge
import megengine.functional as F
from megengine import tensor
import numpy as np
from megengine.functional.nn import nms
from config import config
from det_opr.bbox_opr import bbox_transform_inv_opr, clip_boxes_opr, \
filter_boxes_opr, box_overlap_opr
# from bbox_opr import box_overlap_opr
i... | [
"megengine.functional.nn.nms",
"megengine.functional.prod",
"megengine.functional.minimum",
"megengine.functional.argsort",
"megengine.tensor",
"megengine.functional.cond_take",
"megengine.functional.concat",
"megengine.functional.ones",
"megengine.functional.softmax"
] | [((2223, 2261), 'megengine.functional.concat', 'F.concat', (['batch_proposals_list'], {'axis': '(0)'}), '(batch_proposals_list, axis=0)\n', (2231, 2261), True, 'import megengine.functional as F\n'), ((2284, 2318), 'megengine.functional.concat', 'F.concat', (['batch_probs_list'], {'axis': '(0)'}), '(batch_probs_list, ax... |
#!/usr/bin/env python
# This code was adapted from http://sfepy.org/doc-devel/mat_optim.html.
"""
Compare various elastic materials w.r.t. uniaxial tension/compression test.
Requires Matplotlib.
"""
from __future__ import absolute_import
from argparse import ArgumentParser, RawDescriptionHelpFormatter
import sys
impo... | [
"sfepy.base.conf.get_standard_keywords",
"sfepy.base.base.output.set_output",
"sfepy.discrete.Problem.from_conf",
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.discrete.fem.meshio.UserMeshIO",
"sfepy.mesh.mesh_generators.gen_block_mesh",
"sfepy.base.plotutils.plt.show",
"sfepy.mechanics.matcoefs.sti... | [((327, 347), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (342, 347), False, 'import sys\n'), ((1326, 1347), 'sfepy.discrete.fem.meshio.UserMeshIO', 'UserMeshIO', (['mesh_hook'], {}), '(mesh_hook)\n', (1336, 1347), False, 'from sfepy.discrete.fem.meshio import UserMeshIO\n'), ((4671, 4702), 'num... |
import uuid
from typing import List
from typing import Optional
from sqlalchemy.engine import Engine
from sqlmodel import Field
from sqlmodel import Relationship
from sqlmodel import Session
from sqlmodel import SQLModel
from sqlmodel import create_engine
_engine: Optional[Engine] = None
class FileTagAssociation(SQ... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Relationship",
"sqlmodel.Field",
"sqlmodel.create_engine"
] | [((376, 436), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""file.id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='file.id', primary_key=True)\n", (381, 436), False, 'from sqlmodel import Field\n'), ((485, 544), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"... |
# -*- 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.BatchNorm2d",
"megengine.autodiff.GradManager"
] | [((630, 664), 'megengine.module.BatchNorm2d', 'BatchNorm2d', (['nchannel'], {'freeze': '(True)'}), '(nchannel, freeze=True)\n', (641, 664), False, 'from megengine.module import BatchNorm2d\n'), ((1445, 1493), 'megengine.module.BatchNorm2d', 'BatchNorm2d', (['nchannel'], {'track_running_stats': '(False)'}), '(nchannel, ... |
# -*- 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.distributed.is_distributed",
"megengine.data.transform.ToMode",
"megengine.data.transform.CenterCrop",
"megengine.data.transform.Normalize",
"megengine.data.SequentialSampler",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.get_logger",
"megengine.dat... | [((866, 890), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (880, 890), True, 'import megengine as mge\n'), ((918, 943), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (941, 943), False, 'import argparse\n'), ((2188, 2217), 'collections.defaultdict', 'collections... |
import megengine as mge
import megengine.module as M
import megengine.functional as F
from megengine.core import Parameter
from utils import *
def addLeakyRelu(x):
return M.Sequential(x, M.LeakyReLU(0.1))
def addSig(x):
return M.Sequential(x, M.Sigmoid())
def up_block(x, ic, oc):
return M.ConvTranspose2d... | [
"megengine.module.ConvTranspose2d",
"megengine.functional.maximum",
"megengine.module.LeakyReLU",
"megengine.module.Conv2d",
"megengine.module.AvgPool2d",
"megengine.module.Sigmoid",
"megengine.module.Identity",
"megengine.functional.dimshuffle",
"megengine.functional.concat"
] | [((303, 352), 'megengine.module.ConvTranspose2d', 'M.ConvTranspose2d', (['ic', 'oc', '(4)'], {'stride': '(2)', 'padding': '(1)'}), '(ic, oc, 4, stride=2, padding=1)\n', (320, 352), True, 'import megengine.module as M\n'), ((392, 432), 'megengine.module.Conv2d', 'M.Conv2d', (['ic', 'oc', '(3)'], {'padding': '(1)', 'stri... |
from sfepy.base.testing import TestCommon
class Test(TestCommon):
@staticmethod
def from_conf(conf, options):
return Test(conf=conf, options=options)
def test_elastic_constants(self):
import numpy as nm
from sfepy.mechanics.matcoefs import ElasticConstants
ok = True
... | [
"sfepy.mechanics.matcoefs.bulk_from_lame",
"sfepy.mechanics.matcoefs.lame_from_youngpoisson",
"sfepy.mechanics.matcoefs.stiffness_from_lame_mixed",
"sfepy.mechanics.matcoefs.stiffness_from_lame",
"sfepy.base.base.assert_",
"sfepy.mechanics.matcoefs.ElasticConstants",
"sfepy.mechanics.matcoefs.bulk_from_... | [((398, 431), 'sfepy.mechanics.matcoefs.ElasticConstants', 'ElasticConstants', ([], {'lam': '(1.0)', 'mu': '(1.5)'}), '(lam=1.0, mu=1.5)\n', (414, 431), False, 'from sfepy.mechanics.matcoefs import ElasticConstants\n'), ((1359, 1394), 'sfepy.mechanics.matcoefs.ElasticConstants', 'mc.ElasticConstants', ([], {'lam': 'lam... |
# -*- 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.data.transform.Normalize",
"megengine.data.SequentialSampler",
"megengine.jit.trace",
"megengine.tensor",
"megengine.data.dataset.Cityscapes",
"megengine.load"
] | [((813, 838), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (836, 838), False, 'import argparse\n'), ((1203, 1239), 'official.vision.segmentation.utils.import_config_from_file', 'import_config_from_file', (['args.config'], {}), '(args.config)\n', (1226, 1239), False, 'from official.vision.segm... |
#!/usr/bin/env python
"""
Plot logs of variables saved in a text file by sfepy.base.log.Log class.
The plot should be almost the same as the plot that would be generated by the
Log directly.
"""
from __future__ import absolute_import
import sys
sys.path.append('.')
from argparse import ArgumentParser, Action, RawDescr... | [
"sfepy.base.log.plot_log",
"sfepy.base.log.read_log"
] | [((246, 266), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (261, 266), False, 'import sys\n'), ((1116, 1201), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '__doc__', 'formatter_class': 'RawDescriptionHelpFormatter'}), '(description=__doc__, formatter_class=RawDescriptionHelpF... |
# 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.functional.sigmoid",
"megengine.jit.trace",
"megengine.functional.exp",
"megengine.core.tensor",
"megengine.functional.maximum",
"megengine.functional.grad",
"megengine.functional.round"
] | [((715, 725), 'megengine.core.tensor', 'tensor', (['av'], {}), '(av)\n', (721, 725), False, 'from megengine.core import Function, tensor\n'), ((734, 744), 'megengine.core.tensor', 'tensor', (['bv'], {}), '(bv)\n', (740, 744), False, 'from megengine.core import Function, tensor\n'), ((1339, 1349), 'megengine.core.tensor... |
from typing import Optional
from sqlmodel import SQLModel, Field, create_engine, Session
engine = create_engine(url="sqlite:///users.db", echo=True)
class User(SQLModel, table=True):
id:Optional[int] = Field(None, primary_key=True)
username: str
password:str
def get_session():
with Session(engine) as... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.create_engine",
"sqlmodel.Session"
] | [((99, 149), 'sqlmodel.create_engine', 'create_engine', ([], {'url': '"""sqlite:///users.db"""', 'echo': '(True)'}), "(url='sqlite:///users.db', echo=True)\n", (112, 149), False, 'from sqlmodel import SQLModel, Field, create_engine, Session\n'), ((208, 237), 'sqlmodel.Field', 'Field', (['None'], {'primary_key': '(True)... |
import datetime
from sqlmodel import Field, Relationship, SQLModel
class User(SQLModel, table=True):
__tablename__ = "users"
id: int = Field(primary_key=True)
create_at: datetime.datetime = Field(default_factory=lambda: datetime.datetime.utcnow())
user_name: str
password: str
alias: str
| [
"sqlmodel.Field"
] | [((146, 169), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (151, 169), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((235, 261), 'datetime.datetime.utcnow', 'datetime.datetime.utcnow', ([], {}), '()\n', (259, 261), False, 'import datetime\n')] |
from __future__ import absolute_import
import numpy as nm
from sfepy.base.base import output, OneTypeList, Struct
from sfepy.discrete.fem.mesh import Mesh
from sfepy.discrete.fem.meshio import MeshIO
from sfepy.solvers.ts import TimeStepper
from sfepy.base.ioutils import get_trunk, write_dict_hdf5
import six
from six.... | [
"sfepy.base.ioutils.write_dict_hdf5",
"sfepy.base.base.OneTypeList",
"sfepy.discrete.fem.meshio.MeshIO.any_from_filename",
"sfepy.base.base.output",
"sfepy.base.ioutils.get_trunk",
"sfepy.discrete.fem.mesh.Mesh.from_file"
] | [((417, 435), 'six.iteritems', 'six.iteritems', (['out'], {}), '(out)\n', (430, 435), False, 'import six\n'), ((1525, 1552), 'sfepy.base.base.output', 'output', (['"""dumping to VTK..."""'], {}), "('dumping to VTK...')\n", (1531, 1552), False, 'from sfepy.base.base import output, OneTypeList, Struct\n'), ((1563, 1597),... |
"""Contact Database Tables/Models.
Models of the Endorser tables for Contacts (Authors) and related data.
"""
import uuid
from datetime import datetime
from typing import List
from sqlmodel import Field
from sqlalchemy import Column, func, text, String
from sqlalchemy.dialects.postgresql import UUID, TIMESTAMP, ARRA... | [
"sqlmodel.Field"
] | [((1326, 1347), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (1331, 1347), False, 'from sqlmodel import Field\n'), ((1374, 1395), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (1379, 1395), False, 'from sqlmodel import Field\n'), ((1510, 1531), 'sqlmo... |
from fastapi import APIRouter, Depends
from ..utils import engine, get_session
from sqlmodel import Session, select, or_
from ..models.team import Team
from ..models.user import User
from sqlalchemy.exc import NoResultFound
from datetime import datetime
router = APIRouter(prefix="/api/teams", tags=["team"])
session = ... | [
"sqlmodel.Session",
"sqlmodel.or_",
"sqlmodel.select"
] | [((264, 309), 'fastapi.APIRouter', 'APIRouter', ([], {'prefix': '"""/api/teams"""', 'tags': "['team']"}), "(prefix='/api/teams', tags=['team'])\n", (273, 309), False, 'from fastapi import APIRouter, Depends\n'), ((320, 335), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (327, 335), False, 'from sqlmode... |
#!/usr/bin/env python
"""
Diametrically point loaded 2-D disk, using commands for interactive use. See
:ref:`sec-primer`.
The script combines the functionality of all the ``its2D_?.py`` examples and
allows setting various simulation parameters, namely:
- material parameters
- displacement field approximation order
- ... | [
"sfepy.discrete.conditions.EssentialBC",
"sfepy.discrete.probes.LineProbe",
"sfepy.mechanics.matcoefs.stiffness_from_youngpoisson",
"sfepy.discrete.Integral",
"sfepy.postprocess.viewer.Viewer",
"sfepy.discrete.projections.project_by_component",
"sfepy.solvers.ls.ScipyDirect",
"sfepy.discrete.Integrals... | [((984, 1004), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (999, 1004), False, 'import sys\n'), ((2837, 2849), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (2847, 2849), True, 'import matplotlib.pyplot as plt\n'), ((2854, 2863), 'matplotlib.pyplot.clf', 'plt.clf', ([], {}), '()\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.distributed.helper.get_device_count_by_fork",
"megengine.jit.trace",
"megengine.Tensor",
"megengine.tensor",
"megengine.module.Linear",
"megengine.distributed.get_rank",
"megengine.autodiff.GradManager",
"megengine.Parameter",
"megengine.functional.matmul",
"megengine.distributed.functi... | [((905, 921), 'megengine.tensor', 'mge.tensor', (['(-1.0)'], {}), '(-1.0)\n', (915, 921), True, 'import megengine as mge\n'), ((986, 1000), 'megengine.functional.matmul', 'F.matmul', (['x', 'w'], {}), '(x, w)\n', (994, 1000), True, 'import megengine.functional as F\n'), ((1454, 1474), 'megengine.Parameter', 'mge.Parame... |
import os
import cv2
import argparse
import warnings
import megengine as mge
import megengine.functional as F
warnings.filterwarnings("ignore")
parser = argparse.ArgumentParser(description='Interpolation for a pair of images')
parser.add_argument('--img', dest='img', nargs=2, required=True)
parser.add_argument('--exp'... | [
"megengine.functional.nn.pad"
] | [((110, 143), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (133, 143), False, 'import warnings\n'), ((154, 227), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Interpolation for a pair of images"""'}), "(description='Interpolation for a pa... |
import io
import pickle
import numpy as np
import megengine.functional as F
import megengine.module as M
import megengine.utils.comp_graph_tools as cgtools
from megengine.core._trace_option import set_symbolic_shape
from megengine.jit import trace
from megengine.traced_module import trace_module
set_symbolic_shape(T... | [
"megengine.jit.trace",
"megengine.functional.maximum",
"megengine.functional.zeros",
"megengine.functional.broadcast_to",
"megengine.functional.ones",
"megengine.functional.warp_perspective",
"megengine.core._trace_option.set_symbolic_shape",
"megengine.traced_module.trace_module",
"megengine.utils.... | [((300, 324), 'megengine.core._trace_option.set_symbolic_shape', 'set_symbolic_shape', (['(True)'], {}), '(True)\n', (318, 324), False, 'from megengine.core._trace_option import set_symbolic_shape\n'), ((1612, 1649), 'megengine.functional.ones', 'F.ones', (['(1, 14, 8, 8)'], {'dtype': 'np.uint8'}), '((1, 14, 8, 8), dty... |
from sqlalchemy.sql.schema import MetaData
from sqlmodel import Field, SQLModel
from datetime import datetime
from uuid import UUID, uuid4
class DbtLog(SQLModel, table=True):
"""
Table: __Dbt_Log
"""
__tablename__ = "__Dbt_Log"
Id: UUID = Field(default_factory=uuid4, primary_key=True)
TaskId:... | [
"sqlmodel.Field"
] | [((262, 308), 'sqlmodel.Field', 'Field', ([], {'default_factory': 'uuid4', 'primary_key': '(True)'}), '(default_factory=uuid4, primary_key=True)\n', (267, 308), False, 'from sqlmodel import Field, SQLModel\n'), ((327, 348), 'sqlmodel.Field', 'Field', ([], {'max_length': '(128)'}), '(max_length=128)\n', (332, 348), Fals... |
#!/usr/bin/env python3
# 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.
"""LARS optimizer
References: https://github.com/rwightman/pytorch-image-models/blob/master/timm/optim/lars.py
"""... | [
"megengine.tensor",
"megengine.functional.inplace._inplace_add_",
"megengine.functional.sum"
] | [((2538, 2548), 'megengine.tensor', 'tensor', (['lr'], {}), '(lr)\n', (2544, 2548), False, 'from megengine import Parameter, tensor\n'), ((2573, 2593), 'megengine.tensor', 'tensor', (['weight_decay'], {}), '(weight_decay)\n', (2579, 2593), False, 'from megengine import Parameter, tensor\n'), ((2614, 2630), 'megengine.t... |
"""init
Revision ID: 3b7e032d2384
Revises:
Create Date: 2021-10-01 02:25:02.820531
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
# revision identifiers, used by Alembic.
revision = "3b7e032d2384"
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((3285, 3306), 'alembic.op.drop_table', 'op.drop_table', (['"""prep"""'], {}), "('prep')\n", (3298, 3306), False, 'from alembic import op\n'), ((2977, 3011), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""address"""'], {}), "('address')\n", (3000, 3011), True, 'import sqlalchemy as sa\n'), ((3039,... |
from typing import TYPE_CHECKING, List, Optional
from sqlalchemy import Column
from sqlalchemy.dialects.postgresql import ARRAY
from sqlmodel import AutoString, Field, Relationship, SQLModel
if TYPE_CHECKING:
from .application import Application, ApplicationList
class SchoolBase(SQLModel):
name: str
ab... | [
"sqlmodel.Relationship",
"sqlmodel.AutoString",
"sqlmodel.Field"
] | [((662, 715), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)', 'nullable': '(False)'}), '(default=None, primary_key=True, nullable=False)\n', (667, 715), False, 'from sqlmodel import AutoString, Field, Relationship, SQLModel\n'), ((788, 825), 'sqlmodel.Relationship', 'Relationship', ([], {'b... |
import os, sys
import numpy as np
from config import config
from det_opr.bbox_opr import box_overlap_opr, bbox_transform_opr
import megengine as mge
from megengine import functional as F
import pdb
def _compute_center(boxes):
ptrx = 0.5 * (boxes[:, 0] + boxes[:, 2])
ptry = 0.5 * (boxes[:, 1] + boxes[:, 3])
... | [
"megengine.functional.zeros",
"megengine.functional.gather",
"megengine.functional.minimum",
"megengine.functional.mean",
"megengine.functional.abs",
"megengine.functional.stack",
"megengine.functional.std",
"megengine.functional.maximum",
"megengine.functional.argsort",
"megengine.functional.cond... | [((330, 359), 'megengine.functional.stack', 'F.stack', (['[ptrx, ptry]'], {'axis': '(1)'}), '([ptrx, ptry], axis=1)\n', (337, 359), True, 'from megengine import functional as F\n'), ((687, 716), 'megengine.functional.stack', 'F.stack', (['[l, t, r, b]'], {'axis': '(1)'}), '([l, t, r, b], axis=1)\n', (694, 716), True, '... |
# 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 ARRANTIES OR CONDITIONS OF ANY ... | [
"megengine.core._imperative_rt.core2._get_amp_low_prec_dtype",
"megengine.core._imperative_rt.core2._get_amp_high_prec_dtype",
"megengine.device.get_device_count",
"megengine.core._trace_option.use_symbolic_shape",
"megengine.core._imperative_rt.core2._get_amp_dtype_autocast",
"megengine.core.get_option",... | [((873, 896), 'megengine.device.get_device_count', 'get_device_count', (['"""gpu"""'], {}), "('gpu')\n", (889, 896), False, 'from megengine.device import get_device_count\n'), ((900, 928), 'pytest.fixture', 'pytest.fixture', ([], {'autouse': '(True)'}), '(autouse=True)\n', (914, 928), False, 'import pytest\n'), ((1213,... |
from typing import List
from app.schemas.role import IRoleCreate, IRoleUpdate
from app.models.role import Role
from app.models.user import User
from app.crud.base_sqlmodel import CRUDBase
from sqlmodel.ext.asyncio.session import AsyncSession
from datetime import datetime
from sqlmodel import select
from uuid import UUI... | [
"sqlmodel.select"
] | [((504, 516), 'sqlmodel.select', 'select', (['Role'], {}), '(Role)\n', (510, 516), False, 'from sqlmodel import select\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.hub.load"
] | [((1489, 1554), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""mode"""', "['normal', 'group', 'transpose']"], {}), "('mode', ['normal', 'group', 'transpose'])\n", (1512, 1554), False, 'import pytest\n'), ((2238, 2285), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""mode"""', "['max', 'avg']"],... |
# coding=utf8
from __future__ import absolute_import
import os
from sfepy import data_dir
import six
filename_meshes = ['/meshes/3d/cylinder.mesh',
'/meshes/3d/cylinder.vtk',
'/meshes/various_formats/small2d.mesh',
'/meshes/various_formats/small2d.vtk',
... | [
"sfepy.discrete.fem.meshio.HDF5MeshIO",
"sfepy.base.ioutils.Uncached",
"sfepy.solvers.ts.TimeStepper",
"sfepy.base.ioutils.Cached",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.iga.domain_generators.gen_patch_block_domain",
"sfepy.base.base.Struct",
"sfepy.base.base.assert_",
"sfepy.base.iou... | [((1816, 1837), 'sfepy.discrete.fem.meshio.UserMeshIO', 'UserMeshIO', (['mesh_hook'], {}), '(mesh_hook)\n', (1826, 1837), False, 'from sfepy.discrete.fem.meshio import UserMeshIO\n'), ((2467, 2487), 'os.path.dirname', 'op.dirname', (['__file__'], {}), '(__file__)\n', (2477, 2487), True, 'import os.path as op\n'), ((370... |
"""Instancia da tabela User e seus metodos"""
from typing import Optional, List, TYPE_CHECKING
from datetime import datetime
from sqlalchemy import UniqueConstraint
from sqlmodel import SQLModel, Field, Relationship
if TYPE_CHECKING:
from .tokens import Token
class User(SQLModel, table=True):
"""Tabela de us... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((418, 471), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)', 'default': 'None', 'nullable': '(False)'}), '(primary_key=True, default=None, nullable=False)\n', (423, 471), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((692, 727), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populate... |
#!/usr/bin/env python3
import asyncio
import datetime
import json
import os
import time
from argparse import ArgumentParser
from collections.abc import Sequence
import httpx
import uvloop
from dotenv import load_dotenv
from loguru import logger
from sqlmodel import Session, create_engine
from steam2sqlite import APP... | [
"sqlmodel.create_engine",
"sqlmodel.Session"
] | [((538, 551), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (549, 551), False, 'from dotenv import load_dotenv\n'), ((567, 591), 'os.getenv', 'os.getenv', (['"""APPIDS_FILE"""'], {}), "('APPIDS_FILE')\n", (576, 591), False, 'import os\n'), ((1478, 1494), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '... |
# -*- 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.Dropout",
"megengine.jit.trace",
"megengine.functional.dropout",
"megengine.random.uniform",
"megengine.ones",
"megengine.random.gaussian",
"megengine.random.manual_seed"
] | [((585, 609), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (594, 609), True, 'import megengine.jit as jit\n'), ((679, 703), 'megengine.jit.trace', 'jit.trace', ([], {'symbolic': '(True)'}), '(symbolic=True)\n', (688, 703), True, 'import megengine.jit as jit\n'), ((891, 915), 'm... |
from typing import Optional
from sqlmodel import SQLModel, Field, func, DateTime, Column, Boolean
from datetime import datetime
class BaseModel(SQLModel):
"""
BaseModel class
"""
class Config:
use_enum_values = True
class BaseTableFields(SQLModel):
"""
BaseTableField class
"""
... | [
"sqlmodel.func.now",
"sqlmodel.Field",
"sqlmodel.Column",
"sqlmodel.DateTime"
] | [((344, 397), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)', 'nullable': '(False)'}), '(default=None, primary_key=True, nullable=False)\n', (349, 397), False, 'from sqlmodel import SQLModel, Field, func, DateTime, Column, Boolean\n'), ((937, 989), 'sqlmodel.Column', 'Column', (['Boolean'],... |
# -*- 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.jit.trace",
"megengine.tensor",
"megengine.functional.sort"
] | [((3460, 3519), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""is_symbolic"""', '[None, False, True]'], {}), "('is_symbolic', [None, False, True])\n", (3483, 3519), False, 'import pytest\n'), ((6105, 6157), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""descending"""', '[True, False]'], {}), "... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Aug 9 19:16:05 2021
@author: shrohanmohapatra
"""
r"""
Navier-Stokes equations for incompressible fluid flow in 2D.
Find :math:`\ul{u}`, :math:`p` such that:
.. math::
\int_{\Omega} \nu\ \nabla \ul{v} : \nabla \ul{u}
+ \int_{\Omega} ((\ul{u}... | [
"sfepy.mesh.mesh_generators.gen_block_mesh",
"sfepy.discrete.fem.meshio.UserMeshIO"
] | [((1195, 1216), 'sfepy.discrete.fem.meshio.UserMeshIO', 'UserMeshIO', (['mesh_hook'], {}), '(mesh_hook)\n', (1205, 1216), False, 'from sfepy.discrete.fem.meshio import UserMeshIO\n'), ((1312, 1360), 'numpy.sqrt', 'nm.sqrt', (['(coors[:, 0] ** 2.0 + coors[:, 1] ** 2.0)'], {}), '(coors[:, 0] ** 2.0 + coors[:, 1] ** 2.0)\... |
import re
from datetime import datetime
from enum import Enum
from functools import lru_cache
from inspect import Parameter, signature
from typing import (
TYPE_CHECKING,
Any,
Callable,
Generator,
Generic,
List,
Optional,
Tuple,
Type,
TypeVar,
Union,
)
from uuid import UUID
... | [
"sqlmodel.Field"
] | [((2437, 2467), 'sqlalchemy.ext.compiler.compiles', 'compiles', (['utcnow', '"""postgresql"""'], {}), "(utcnow, 'postgresql')\n", (2445, 2467), False, 'from sqlalchemy.ext.compiler import compiles\n'), ((2585, 2610), 'sqlalchemy.ext.compiler.compiles', 'compiles', (['utcnow', '"""mssql"""'], {}), "(utcnow, 'mssql')\n",... |
import traceback
from contextlib import contextmanager
from sqlmodel import create_engine, Session
from fastapi_dream_core.application_dependencies.application_dependencies_abc import ApplicationDependenciesABC
from fastapi_dream_core.utils import logger
class DatabaseSQLModel(ApplicationDependenciesABC):
def ... | [
"sqlmodel.create_engine",
"sqlmodel.Session"
] | [((408, 448), 'sqlmodel.create_engine', 'create_engine', (['db_url'], {'echo': 'echo_queries'}), '(db_url, echo=echo_queries)\n', (421, 448), False, 'from sqlmodel import create_engine, Session\n'), ((496, 517), 'sqlmodel.Session', 'Session', (['self._engine'], {}), '(self._engine)\n', (503, 517), False, 'from sqlmodel... |
import os
import sys
import time
import logging
from collections import namedtuple
import megengine as mge
import megengine.distributed as dist
import megengine.functional as F
import megengine.autodiff as autodiff
import megengine.optimizer as optim
import yaml
from tensorboardX import SummaryWriter
from nets impor... | [
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.data.DataLoader",
"megengine.get_device_count",
"megengine.load",
"megengine.functional.abs",
"megengine.tensor",
"megengine.functional.concat",
"megengine.amp.GradScaler",
"megengine.distributed.make_allreduce_cb... | [((2048, 2074), 'megengine.random.seed', 'mge.random.seed', (['args.seed'], {}), '(args.seed)\n', (2063, 2074), True, 'import megengine as mge\n'), ((2141, 2157), 'megengine.dtr.enable', 'mge.dtr.enable', ([], {}), '()\n', (2155, 2157), True, 'import megengine as mge\n'), ((2261, 2297), 'os.path.join', 'os.path.join', ... |
#!/usr/bin/env python
"""
Transient Laplace equation (heat equation) with non-constant initial conditions
given by a function, using commands for interactive use.
The script allows setting various simulation parameters, namely:
- the diffusivity coefficient
- the max. initial condition value
- temperature field appro... | [
"sfepy.discrete.conditions.InitialCondition",
"sfepy.base.base.IndexedStruct",
"sfepy.solvers.ts_solvers.SimpleTimeSteppingSolver",
"sfepy.base.base.assert_",
"sfepy.discrete.Equation",
"sfepy.base.base.ordered_iteritems",
"sfepy.discrete.projections.project_by_component",
"sfepy.discrete.conditions.E... | [((648, 668), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (663, 668), False, 'import sys\n'), ((1705, 1752), 'sfepy.discrete.probes.LineProbe', 'LineProbe', (['p0', 'p1', 'n_point'], {'share_geometry': '(True)'}), '(p0, p1, n_point, share_geometry=True)\n', (1714, 1752), False, 'from sfepy.discr... |
from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
from geoalchemy2.types import Geometry
from sqlmodel import Session, cast, select
from .database import engine
from .models import Country
app = FastAPI()
templates = Jinja2Templates(director... | [
"sqlmodel.cast",
"sqlmodel.Session"
] | [((274, 283), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (281, 283), False, 'from fastapi import FastAPI, Request\n'), ((296, 347), 'fastapi.templating.Jinja2Templates', 'Jinja2Templates', ([], {'directory': '"""geo_info_svg/templates"""'}), "(directory='geo_info_svg/templates')\n", (311, 347), False, 'from fastap... |
r"""
Incompressible Stokes flow with Navier (slip) boundary conditions, flow driven
by a moving wall and a small diffusion for stabilization.
This example demonstrates the use of `no-penetration` and `edge direction`
boundary conditions together with Navier or slip boundary conditions.
Alternatively the `no-penetratio... | [
"sfepy.base.base.assert_",
"sfepy.discrete.fem.meshio.UserMeshIO",
"sfepy.homogenization.utils.define_box_regions",
"sfepy.mesh.mesh_generators.gen_block_mesh"
] | [((5428, 5464), 'sfepy.base.base.assert_', 'assert_', (["(mode in {'lcbc', 'penalty'})"], {}), "(mode in {'lcbc', 'penalty'})\n", (5435, 5464), False, 'from sfepy.base.base import assert_, output\n'), ((5469, 5513), 'sfepy.base.base.assert_', 'assert_', (["(term_mode in {'original', 'einsum'})"], {}), "(term_mode in {'... |
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import megengine as mge
import megengine.functional as F
import megengine.module as M
__all__ = ["fuse_conv_and_bn", "fuse_model", "replace_module"]
def fuse_conv_and_bn(conv, bn):
# Fuse convolution and bat... | [
"megengine.functional.zeros",
"megengine.Parameter",
"megengine.functional.sqrt",
"megengine.module.Conv2d"
] | [((403, 555), 'megengine.module.Conv2d', 'M.Conv2d', (['conv.in_channels', 'conv.out_channels'], {'kernel_size': 'conv.kernel_size', 'stride': 'conv.stride', 'padding': 'conv.padding', 'groups': 'conv.groups', 'bias': '(True)'}), '(conv.in_channels, conv.out_channels, kernel_size=conv.kernel_size,\n stride=conv.stri... |
from sqlmodel import Session, select
from config.Database import Database
class UserDatabase(Database):
def __init__(self) -> None:
super(UserDatabase, self).__init__()
async def get_by_params(self, object: object, email: str):
with Session(self._engine) as session:
statement = sel... | [
"sqlmodel.Session",
"sqlmodel.select"
] | [((259, 280), 'sqlmodel.Session', 'Session', (['self._engine'], {}), '(self._engine)\n', (266, 280), False, 'from sqlmodel import Session, select\n'), ((317, 331), 'sqlmodel.select', 'select', (['object'], {}), '(object)\n', (323, 331), False, 'from sqlmodel import Session, select\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._internal.dtype.get_scale",
"megengine._internal.dtype.qint32"
] | [((1670, 1700), 'megengine._internal.dtype.get_scale', 'mgb.dtype.get_scale', (['inp.dtype'], {}), '(inp.dtype)\n', (1689, 1700), True, 'import megengine._internal as mgb\n'), ((1719, 1757), 'megengine._internal.dtype.get_scale', 'mgb.dtype.get_scale', (['self.weight.dtype'], {}), '(self.weight.dtype)\n', (1738, 1757),... |
# 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"
] | [((1149, 1189), 'hypothesis.strategies.sampled_from', 'st.sampled_from', (['(str, float, bool, int)'], {}), '((str, float, bool, int))\n', (1164, 1189), True, 'from hypothesis import strategies as st\n'), ((1202, 1303), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)', 'sa_column_kwargs': "{'... |
from enum import Enum
from typing import Optional
from sqlmodel import Field, SQLModel
class ExtensionType(str, Enum):
DOCKER = 'DOCKER'
WEBHOOK = 'WEBHOOK'
BINARY = 'BINARY'
class Extension(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
# condition is a small p... | [
"sqlmodel.Field"
] | [((254, 291), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (259, 291), False, 'from sqlmodel import Field, SQLModel\n')] |
from __future__ import absolute_import
import numpy as nm
from sfepy.base.base import output, assert_, get_default, Struct
from sfepy.homogenization.coefs_base import CorrSolution, \
TCorrectorsViaPressureEVP, CorrMiniApp
from sfepy.solvers.ts import TimeStepper
from six.moves import range
class PressureRHSVecto... | [
"sfepy.homogenization.coefs_base.CorrSolution",
"sfepy.base.base.get_default",
"sfepy.base.base.assert_"
] | [((416, 450), 'sfepy.base.base.get_default', 'get_default', (['problem', 'self.problem'], {}), '(problem, self.problem)\n', (427, 450), False, 'from sfepy.base.base import output, assert_, get_default, Struct\n'), ((1204, 1238), 'sfepy.base.base.get_default', 'get_default', (['problem', 'self.problem'], {}), '(problem,... |
import numpy as nm
from sfepy.base.base import assert_
from sfepy.linalg import dot_sequences
from sfepy.terms.terms import Term, terms
class ZeroTerm(Term):
r"""
A do-nothing term useful for introducing additional variables into the
equations.
:Definition:
.. math::
0
:Arguments:
... | [
"sfepy.linalg.dot_sequences",
"sfepy.base.base.assert_"
] | [((6427, 6453), 'numpy.ascontiguousarray', 'nm.ascontiguousarray', (['bf_t'], {}), '(bf_t)\n', (6447, 6453), True, 'import numpy as nm\n'), ((6749, 6783), 'sfepy.base.base.assert_', 'assert_', (['(virtual.n_components == 1)'], {}), '(virtual.n_components == 1)\n', (6756, 6783), False, 'from sfepy.base.base import asser... |
# -*- 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.load",
"megengine.functional.grad",
"megengine.core.TensorDict",
"megengine.core.tensor"
] | [((7391, 7420), 'helpers.graph_mode', 'graph_mode', (['"""eager"""', '"""static"""'], {}), "('eager', 'static')\n", (7401, 7420), False, 'from helpers import MLP, graph_mode\n'), ((829, 837), 'megengine.core.tensor', 'tensor', ([], {}), '()\n', (835, 837), False, 'from megengine.core import TensorDict, tensor\n'), ((85... |
#!/usr/bin/env python
"""
Convert a mesh file from one SfePy-supported format to another.
Examples::
$ ./script/convert_mesh.py meshes/3d/cylinder.mesh new.vtk
$ ./script/convert_mesh.py meshes/3d/cylinder.mesh new.vtk -s2.5
$ ./script/convert_mesh.py meshes/3d/cylinder.mesh new.vtk -s0.5,2,1
$ ./script/conve... | [
"sfepy.discrete.fem.meshio.output_mesh_formats",
"sfepy.base.base.nm.diag",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.base.base.nm.array",
"sfepy.base.base.nm.eye",
"sfepy.discrete.fem.meshio.MeshIO.for_format",
"sfepy.discrete.fem.FEDomain",
"sfepy.base.base.output"
] | [((393, 413), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (408, 413), False, 'import sys\n'), ((1680, 1705), 'optparse.OptionParser', 'OptionParser', ([], {'usage': 'usage'}), '(usage=usage)\n', (1692, 1705), False, 'from optparse import OptionParser\n'), ((3131, 3158), 'sfepy.discrete.fem.Mesh.... |
import numpy as np
from sfepy.base.goptions import goptions
from sfepy.discrete.fem import Field
try:
from sfepy.discrete.fem import FEDomain as Domain
except ImportError:
from sfepy.discrete.fem import Domain
from sfepy.discrete import (FieldVariable, Material, Integral, Function,
E... | [
"sfepy.discrete.conditions.EssentialBC",
"sfepy.base.base.output.set_output",
"sfepy.discrete.Integral",
"sfepy.solvers.ls.ScipyDirect",
"sfepy.discrete.Equations",
"sfepy.discrete.fem.Field.from_args",
"sfepy.discrete.Equation",
"sfepy.discrete.Function",
"sfepy.mechanics.matcoefs.stiffness_from_la... | [((839, 868), 'sfepy.base.base.output.set_output', 'output.set_output', ([], {'quiet': '(True)'}), '(quiet=True)\n', (856, 868), False, 'from sfepy.base.base import output\n'), ((6954, 6970), 'numpy.array', 'np.array', (['strain'], {}), '(strain)\n', (6962, 6970), True, 'import numpy as np\n'), ((6999, 7021), 'numpy.ar... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import os
from typing import Iterable, Union
from megengine import Parameter, tensor
from megengine.functional.inplace import _inplace_add_
from megengine.optimizer import Optimizer
class SGD(Optimizer):
r"""Implements stochastic g... | [
"megengine.tensor",
"megengine.functional.inplace._inplace_add_"
] | [((2154, 2164), 'megengine.tensor', 'tensor', (['lr'], {}), '(lr)\n', (2160, 2164), False, 'from megengine import Parameter, tensor\n'), ((2189, 2209), 'megengine.tensor', 'tensor', (['weight_decay'], {}), '(weight_decay)\n', (2195, 2209), False, 'from megengine import Parameter, tensor\n'), ((2230, 2246), 'megengine.t... |
from typing import Union
from uuid import uuid4
import inject
from sqlmodel import Session, select
from src.core.events import EventDescription
from src.core.models import Context, File
from src.core.services import Storage, Streamer
from src.utils.miscellaneous import get_file_hash
@inject.params(streamer=Streamer... | [
"sqlmodel.select"
] | [((289, 338), 'inject.params', 'inject.params', ([], {'streamer': 'Streamer', 'storage': 'Storage'}), '(streamer=Streamer, storage=Storage)\n', (302, 338), False, 'import inject\n'), ((1318, 1348), 'inject.params', 'inject.params', ([], {'storage': 'Storage'}), '(storage=Storage)\n', (1331, 1348), False, 'import inject... |
from datetime import date
from fastapi import FastAPI, Query
from sqlmodel import Session, create_engine, select
from .datatypes import ArtmuseumAddress, ArtmuseumTimeLabel
from .db.crud import init_db
from .db.models import ArtmuseumExhibition, PhilharmoniaConcert
sql_engine = create_engine(
"sqlite:///databas... | [
"sqlmodel.create_engine",
"sqlmodel.select",
"sqlmodel.Session"
] | [((283, 369), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite:///database.db"""'], {'connect_args': "{'check_same_thread': False}"}), "('sqlite:///database.db', connect_args={'check_same_thread': \n False})\n", (296, 369), False, 'from sqlmodel import Session, create_engine, select\n'), ((377, 557), 'fastapi... |
import numpy as nm
from sfepy.terms.terms import Term, terms
from sfepy.base.base import get_default
def grad_as_vector(grad):
grad = grad.transpose((0, 1, 3, 2))
sh = grad.shape
return grad.reshape((sh[0], sh[1], sh[2] * sh[3], 1))
class AdjDivGradTerm(Term):
r"""
Gateaux differential of :math:`... | [
"sfepy.base.base.get_default"
] | [((15137, 15177), 'numpy.array', 'nm.array', (['[0]'], {'ndmin': '(4)', 'dtype': 'nm.float64'}), '([0], ndmin=4, dtype=nm.float64)\n', (15145, 15177), True, 'import numpy as nm\n'), ((1341, 1381), 'numpy.array', 'nm.array', (['[0]'], {'ndmin': '(4)', 'dtype': 'nm.float64'}), '([0], ndmin=4, dtype=nm.float64)\n', (1349,... |
import time
from datetime import datetime, timedelta, date
import typer
from sqlalchemy.exc import NoResultFound, OperationalError
from sqlmodel import Session, select, func
from tabulate import tabulate
from . import edit
from . import reports
from .database import create_db_and_tables, engine
from .functions_aux im... | [
"sqlmodel.select",
"sqlmodel.Session",
"sqlmodel.func.max"
] | [((400, 413), 'typer.Typer', 'typer.Typer', ([], {}), '()\n', (411, 413), False, 'import typer\n'), ((600, 637), 'typer.Option', 'typer.Option', (['None', '"""--project"""', '"""-p"""'], {}), "(None, '--project', '-p')\n", (612, 637), False, 'import typer\n'), ((668, 728), 'typer.Option', 'typer.Option', (['None', '"""... |
from __future__ import absolute_import
from sfepy.discrete.fem import Mesh, FEDomain
import scipy.sparse as sps
import numpy as nm
from sfepy.base.compat import factorial
from sfepy.base.base import output
from six.moves import range
def elems_q2t(el):
nel, nnd = el.shape
if nnd > 4:
q2t = nm.array([[... | [
"sfepy.base.compat.factorial",
"sfepy.linalg.utils.dets_fast",
"sfepy.base.timing.Timer",
"sfepy.discrete.fem.Mesh.from_data",
"sfepy.discrete.fem.FEDomain",
"sfepy.base.base.output"
] | [((655, 690), 'numpy.zeros', 'nm.zeros', (['(nel, nn)'], {'dtype': 'nm.int32'}), '((nel, nn), dtype=nm.int32)\n', (663, 690), True, 'import numpy as nm\n'), ((707, 716), 'six.moves.range', 'range', (['ns'], {}), '(ns)\n', (712, 716), False, 'from six.moves import range\n'), ((808, 833), 'numpy.ascontiguousarray', 'nm.a... |
import os
import math
import numpy as np
import six
import megengine._internal as mgb
from enum import Enum
from py_proto import mace_pb2
from transform import base_converter
from transform.base_converter import PoolingType
from transform.base_converter import ActivationType
from transform.base_converter import Eltwis... | [
"megengine._internal.cgtools.graph_traversal",
"megengine._internal.cgtools.get_opr_type",
"megengine._internal.cgtools.get_oprs_seq",
"megengine._internal.load_comp_graph_from_file"
] | [((1313, 1378), 'enum.Enum', 'Enum', (['"""MGEOpType"""', '[(op, op) for op in MGESupportedOps]'], {'type': 'str'}), "('MGEOpType', [(op, op) for op in MGESupportedOps], type=str)\n", (1317, 1378), False, 'from enum import Enum\n'), ((4473, 4490), 'py_proto.mace_pb2.NetDef', 'mace_pb2.NetDef', ([], {}), '()\n', (4488, ... |
"""
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.fields_base.FEField.remove_extra_dofs",
"sfepy.discrete.fem.fields_base.FEField.extend_dofs",
"sfepy.discrete.fem.extmods.bases.evaluate_in_rc",
"sfepy.discrete.common.dof_info.expand_nodes_to_dofs",
"sfepy.discrete.fem.global_interp.get_ref_coors",
"sfepy.base.base.output",
"sfepy.d... | [((2552, 2572), 'numpy.array', 'nm.array', (['facet_desc'], {}), '(facet_desc)\n', (2560, 2572), True, 'import numpy as nm\n'), ((2711, 2753), 'numpy.arange', 'nm.arange', (['facets.shape[0]'], {'dtype': 'nm.int32'}), '(facets.shape[0], dtype=nm.int32)\n', (2720, 2753), True, 'import numpy as nm\n'), ((2911, 2948), 'sf... |
from sqlmodel import Session, select
from db import BaseDBModel
from service.base_crud import BaseCRUD
class TestTable(BaseDBModel, table=True):
test_str: str
test_int: int
TEST_ROW_DATA1 = {'test_str': 'str1', 'test_int': 1}
TEST_ROW_DATA2 = {'test_str': 'str2', 'test_int': 2}
class TestCRUD(BaseCRUD):
... | [
"sqlmodel.select"
] | [((2249, 2266), 'sqlmodel.select', 'select', (['TestTable'], {}), '(TestTable)\n', (2255, 2266), False, 'from sqlmodel import Session, select\n'), ((2857, 2874), 'sqlmodel.select', 'select', (['TestTable'], {}), '(TestTable)\n', (2863, 2874), False, 'from sqlmodel import Session, select\n')] |
# Copyright (c) Megvii, Inc. and its affiliates.
import math
import megengine.functional as F
import megengine.module as M
class LogitsFullyConnected(M.Module):
"""single fully connected layer, mapping embedding to logits with normalized weight
"""
def __init__(self, num_class, feature_dim):
su... | [
"megengine.module.Linear",
"megengine.functional.normalize",
"megengine.functional.topk_accuracy",
"megengine.functional.where",
"megengine.functional.acos",
"megengine.functional.one_hot",
"megengine.functional.loss.cross_entropy"
] | [((350, 394), 'megengine.module.Linear', 'M.Linear', (['feature_dim', 'num_class'], {'bias': '(False)'}), '(feature_dim, num_class, bias=False)\n', (358, 394), True, 'import megengine.module as M\n'), ((532, 564), 'megengine.functional.normalize', 'F.normalize', (['self.weight'], {'axis': '(1)'}), '(self.weight, axis=1... |
import os
from pathlib import Path
from app import MyApp
from dotenv import load_dotenv
from sqlmodel import Session, SQLModel, create_engine
load_dotenv()
MOVIES_PATH = Path(os.getenv("MOVIES_FILEPATH", None))
dbfile = Path("database.db")
engine = create_engine("sqlite:///database.db", echo=False)
def create_db_... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.create_engine"
] | [((144, 157), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (155, 157), False, 'from dotenv import load_dotenv\n'), ((224, 243), 'pathlib.Path', 'Path', (['"""database.db"""'], {}), "('database.db')\n", (228, 243), False, 'from pathlib import Path\n'), ((253, 303), 'sqlmodel.create_engine', 'create_engine', ([... |
import math
import numpy
import megengine as mge
import megengine.module as M
import megengine.functional as F
from .layer_norm import LayerNorm
class DecoderLayer(M.Module):
"""Single decoder layer module."""
def __init__(
self,
size,
self_attn,
src_attn,
feed_forwar... | [
"megengine.module.dropout.Dropout",
"megengine.functional.concat"
] | [((744, 775), 'megengine.module.dropout.Dropout', 'M.dropout.Dropout', (['dropout_rate'], {}), '(dropout_rate)\n', (761, 775), True, 'import megengine.module as M\n'), ((2705, 2733), 'megengine.functional.concat', 'F.concat', (['[cache, x]'], {'axis': '(1)'}), '([cache, x], axis=1)\n', (2713, 2733), True, 'import megen... |
# -*- 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.jit.trace",
"megengine.distributed.init_process_group",
"megengine.distributed.is_distributed",
"megengine.functional.cross_entropy_with_softmax",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.data.transform.CenterCrop",
"megengine.get_device_count",
... | [((909, 933), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (923, 933), True, 'import megengine as mge\n'), ((961, 986), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (984, 986), False, 'import argparse\n'), ((3464, 3488), 'megengine.jit.trace', 'jit.trace', ([]... |
# -*- 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.cgtools.get_dep_vars",
"megengine._internal.opr.callback_injector",
"megengine._internal.make_arg",
"megengine._internal.plugin.CompGraphProfiler",
"megengine._internal.serialize_comp_graph_to_file",
"megengine._internal.optimize_for_inference",
"megengine._internal.comp_graph_tools... | [((865, 883), 'functools.wraps', 'functools.wraps', (['f'], {}), '(f)\n', (880, 883), False, 'import functools\n'), ((3018, 3048), 'os.getenv', 'os.getenv', (['"""MGE_DISABLE_TRACE"""'], {}), "('MGE_DISABLE_TRACE')\n", (3027, 3048), False, 'import os\n'), ((5194, 5236), 'megengine._internal.opr.virtual_dep', 'mgb.opr.v... |
#!/usr/bin/env python3
from dataset import SIDDValData
from model import UNetD
import megengine.data as data
from utils import batch_PSNR
from tqdm import tqdm
import argparse
import pickle
import megengine
def test(args):
valid_dataset = SIDDValData(args.data)
valid_sampler = data.SequentialSampler(
... | [
"megengine.data.DataLoader",
"megengine.tensor",
"megengine.data.SequentialSampler"
] | [((245, 267), 'dataset.SIDDValData', 'SIDDValData', (['args.data'], {}), '(args.data)\n', (256, 267), False, 'from dataset import SIDDValData\n'), ((288, 356), 'megengine.data.SequentialSampler', 'data.SequentialSampler', (['valid_dataset'], {'batch_size': '(1)', 'drop_last': '(False)'}), '(valid_dataset, batch_size=1,... |
from typing import Optional, List
from fastapi import FastAPI, File, UploadFile, Request
from sqlmodel import Field, Session, SQLModel, create_engine, select
from pydantic import BaseModel
from network import Network
import requests
from PIL import Image as ImagePIL
import torchvision as tv
app = FastAPI()
network = N... | [
"sqlmodel.create_engine",
"sqlmodel.select",
"sqlmodel.Session",
"sqlmodel.Field"
] | [((299, 308), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (306, 308), False, 'from fastapi import FastAPI, File, UploadFile, Request\n'), ((319, 328), 'network.Network', 'Network', ([], {}), '()\n', (326, 328), False, 'from network import Network\n'), ((514, 549), 'sqlmodel.create_engine', 'create_engine', (['"""sq... |
from typing import Callable
from sqlmodel import select, Session
from . import BaseRepository, engine
from ..models import ProfileDB, UserDB
from app.shared.exc import (
EmailAlreadyTakenError,
UserDoesNotExist,
UsernameAlreadyTakenError)
class UserRepository(BaseRepository):
model = UserDB
@cl... | [
"sqlmodel.Session",
"sqlmodel.select"
] | [((697, 712), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (704, 712), False, 'from sqlmodel import select, Session\n'), ((1973, 2034), 'app.shared.exc.UsernameAlreadyTakenError', 'UsernameAlreadyTakenError', (['"""Please try a different username."""'], {}), "('Please try a different username.')\n", (... |
# 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 ARRANTIES OR CONDITIONS OF ANY ... | [
"megengine.quantization.quantize.propagate_qconfig",
"megengine.module.Elemwise",
"megengine.module.quantized.Elemwise.from_qat_module",
"megengine.module.qat.Linear",
"megengine.core.tensor.dtype.qint8",
"megengine.module.DequantStub",
"megengine.module.qat.Linear.from_float_module",
"megengine.modul... | [((1778, 1818), 'functools.partial', 'partial', (['fake_quant'], {'qmin': '(-128)', 'qmax': '(127)'}), '(fake_quant, qmin=-128, qmax=127)\n', (1785, 1818), False, 'from functools import partial\n'), ((1839, 1879), 'functools.partial', 'partial', (['fake_quant'], {'qmin': '(-127)', 'qmax': '(127)'}), '(fake_quant, qmin=... |
import pytest
import megengine as mge
import megengine.functional as F
from megengine.core._imperative_rt.core2 import config_async_level, get_async_level
def test_basic():
config_async_level(2)
assert get_async_level() == 2
with pytest.raises(RuntimeError):
config_async_level(3)
def test_level... | [
"megengine.core._imperative_rt.core2.get_async_level",
"megengine.core._imperative_rt.core2.config_async_level",
"megengine.tensor",
"megengine.functional.matmul",
"megengine.functional.reshape"
] | [((180, 201), 'megengine.core._imperative_rt.core2.config_async_level', 'config_async_level', (['(2)'], {}), '(2)\n', (198, 201), False, 'from megengine.core._imperative_rt.core2 import config_async_level, get_async_level\n'), ((341, 362), 'megengine.core._imperative_rt.core2.config_async_level', 'config_async_level', ... |
# -*- coding: utf-8 -*-
# Copyright 2019 - present, Facebook, Inc
#
# 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 app... | [
"megengine.functional.mean",
"megengine.functional.sqrt",
"megengine.module.init.zeros_",
"megengine.module.init.ones_"
] | [((3029, 3066), 'megengine.functional.mean', 'F.mean', (['output'], {'axis': '(2)', 'keepdims': '(True)'}), '(output, axis=2, keepdims=True)\n', (3035, 3066), True, 'import megengine.functional as F\n'), ((3083, 3125), 'megengine.functional.mean', 'F.mean', (['(output ** 2)'], {'axis': '(2)', 'keepdims': '(True)'}), '(... |
# Imports from standard library
import os
from typing import Optional, Union
import asyncio
import time
import sqlite3
import hashlib
# Import these utilities
from utils.merkletree import MerkleTree, MerkleError
# Import the HTTP app server
from fastapi import FastAPI, BackgroundTasks
###############################... | [
"sqlmodel.create_engine",
"sqlmodel.Field"
] | [((6014, 6023), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (6021, 6023), False, 'from fastapi import FastAPI, BackgroundTasks\n'), ((443, 480), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (448, 480), False, 'from sqlmodel import Field, SQLMod... |
# 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._internal.dtype.is_quantize",
"megengine._internal.dtype.is_bfloat16",
"megengine.zeros",
"megengine.get_logger"
] | [((741, 765), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (755, 765), True, 'import megengine as mge\n'), ((1434, 1462), 'numpy.prod', 'np.prod', (['output[0].shape[2:]'], {}), '(output[0].shape[2:])\n', (1441, 1462), True, 'import numpy as np\n'), ((1722, 1749), 'numpy.prod', 'np.prod... |
"""
Query related functions.
"""
from datetime import datetime, timezone
from typing import List, Tuple
import sqlparse
from sqlalchemy import text
from sqlmodel import Session, create_engine
from datajunction.config import Settings
from datajunction.models.query import (
ColumnMetadata,
Query,
QueryResu... | [
"sqlmodel.create_engine"
] | [((1834, 1898), 'sqlmodel.create_engine', 'create_engine', (['query.database.URI'], {}), '(query.database.URI, **query.database.extra_params)\n', (1847, 1898), False, 'from sqlmodel import Session, create_engine\n'), ((2015, 2051), 'sqlparse.parse', 'sqlparse.parse', (['query.executed_query'], {}), '(query.executed_que... |
import numpy as nm
from sfepy.terms.terms import Term, terms
_msg_missing_data = 'missing family data!'
class HyperElasticBase(Term):
"""
Base class for all hyperelastic terms in TL/UL formulation.
`HyperElasticBase.__call__()` computes element contributions given either
stress (-> rezidual) or tange... | [
"sfepy.terms.terms.Term.__init__",
"sfepy.terms.terms.terms.dq_def_grad"
] | [((1195, 1231), 'sfepy.terms.terms.Term.__init__', 'Term.__init__', (['self', '*args'], {}), '(self, *args, **kwargs)\n', (1208, 1231), False, 'from sfepy.terms.terms import Term, terms\n'), ((1967, 2006), 'numpy.empty_like', 'nm.empty_like', (['family_data.green_strain'], {}), '(family_data.green_strain)\n', (1980, 20... |
r"""
Piezo-elasticity problem - linear elastic material with piezoelectric
effects.
Find :math:`\ul{u}`, :math:`\phi` such that:
.. math::
- \omega^2 \int_{Y} \rho\ \ul{v} \cdot \ul{u}
+ \int_{Y} D_{ijkl}\ e_{ij}(\ul{v}) e_{kl}(\ul{u})
- \int_{Y_2} g_{kij}\ e_{ij}(\ul{v}) \nabla_k \phi
= 0
\;, \qu... | [
"sfepy.discrete.fem.MeshIO.any_from_filename"
] | [((1055, 1080), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (1070, 1080), False, 'import os\n'), ((1086, 1146), 'sfepy.discrete.fem.MeshIO.any_from_filename', 'MeshIO.any_from_filename', (['filename_mesh'], {'prefix_dir': 'conf_dir'}), '(filename_mesh, prefix_dir=conf_dir)\n', (1110, 1146)... |
# -*- coding: utf-8 -*-
from datetime import datetime
from typing import Optional
from sqlmodel import Column, DateTime, Field, Relationship, SQLModel
class Device(SQLModel, table=True): # type: ignore
"""The Device model.
It is used to model a device.
"""
# setup the primary key of the table
... | [
"sqlmodel.Field",
"sqlmodel.DateTime",
"sqlmodel.Relationship"
] | [((333, 356), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (338, 356), False, 'from sqlmodel import Column, DateTime, Field, Relationship, SQLModel\n'), ((1560, 1583), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (1565, 1583), False, 'from sq... |
"""
Quantum oscillator.
See :ref:`quantum-quantum_common`.
"""
from __future__ import absolute_import
from sfepy.linalg import norm_l2_along_axis
from examples.quantum.quantum_common import common
def get_exact(n_eigs, box_size, dim):
if dim == 2:
eigs = [1] + [2]*2 + [3]*3 + [4]*4 + [5]*5 + [6]*6
e... | [
"sfepy.linalg.norm_l2_along_axis"
] | [((696, 754), 'examples.quantum.quantum_common.common', 'common', (['fun_v'], {'get_exact': 'get_exact', 'n_eigs': 'n_eigs', 'tau': 'tau'}), '(fun_v, get_exact=get_exact, n_eigs=n_eigs, tau=tau)\n', (702, 754), False, 'from examples.quantum.quantum_common import common\n'), ((536, 582), 'sfepy.linalg.norm_l2_along_axis... |
import os
import numpy as nm
try:
from enthought.tvtk.api import tvtk
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
from enthought.pyface.timer.api import Timer
except:
from tvtk.api import tvtk
from mayavi.sources.vtk_data_source import VTKDataSource
from pyface.timer.ap... | [
"sfepy.postprocess.utils.mlab.pipeline.open",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.fem.meshio.MeshIO.any_from_filename",
"sfepy.discrete.fem.meshio.supported_formats.keys"
] | [((4437, 4459), 'os.stat', 'os.stat', (['self.filename'], {}), '(self.filename)\n', (4444, 4459), False, 'import os\n'), ((4873, 4906), 'sfepy.postprocess.utils.mlab.pipeline.open', 'mlab.pipeline.open', (['self.filename'], {}), '(self.filename)\n', (4891, 4906), False, 'from sfepy.postprocess.utils import mlab\n'), ((... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import argparse
import importlib
import json
import multiprocessing as mp
import os
import pathlib
import sys
import megengine as mge
import megengine.distributed as dist
from basecore.config import ConfigDict
from loguru import logger
... | [
"megengine.distributed.get_rank",
"megengine.device.get_device_count",
"megengine.functional.debug_param.set_execution_strategy",
"megengine.distributed.launcher"
] | [((659, 684), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (682, 684), False, 'import argparse\n'), ((1017, 1042), 'os.path.abspath', 'os.path.abspath', (['args.dir'], {}), '(args.dir)\n', (1032, 1042), False, 'import os\n'), ((1047, 1105), 'basecls.utils.setup_logger', 'setup_logger', (['arg... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.