code stringlengths 110 64.5k | apis list | extract_api stringlengths 123 69.9k |
|---|---|---|
from datetime import datetime, date
from typing import Optional
from fastapi import APIRouter
from sqlmodel import Field, SQLModel
router = APIRouter()
class History(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
patient_id: int
hospital_id: Optional[int]
hospital_n... | [
"sqlmodel.Field"
] | [((142, 153), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (151, 153), False, 'from fastapi import APIRouter\n'), ((217, 254), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (222, 254), False, 'from sqlmodel import Field, SQLModel\n'), ((624, ... |
r"""
Diametrically point loaded 2-D disk with postprocessing and probes. See
:ref:`sec-primer`.
Find :math:`\ul{u}` such that:
.. math::
\int_{\Omega} D_{ijkl}\ e_{ij}(\ul{v}) e_{kl}(\ul{u})
= 0
\;, \quad \forall \ul{v} \;,
where
.. math::
D_{ijkl} = \mu (\delta_{ik} \delta_{jl}+\delta_{il} \delta_{... | [
"sfepy.postprocess.probes_vtk.Probe",
"sfepy.mechanics.matcoefs.stiffness_from_youngpoisson",
"sfepy.base.base.Struct"
] | [((1052, 1115), 'sfepy.base.base.Struct', 'Struct', ([], {'name': '"""output_data"""', 'mode': '"""cell"""', 'data': 'strain', 'dofs': 'None'}), "(name='output_data', mode='cell', data=strain, dofs=None)\n", (1058, 1115), False, 'from sfepy.base.base import Struct\n'), ((1177, 1240), 'sfepy.base.base.Struct', 'Struct',... |
from __future__ import absolute_import
import os
import sfepy
from sfepy.base.base import load_classes, insert_static_method
from .solvers import *
from .eigen import eig
solver_files = sfepy.get_paths('sfepy/solvers/*.py')
remove = ['setup.py', 'solvers.py', 'petsc_worker.py']
solver_files = [name for name in solver_... | [
"sfepy.get_paths",
"sfepy.base.base.insert_static_method",
"sfepy.base.base.load_classes"
] | [((187, 224), 'sfepy.get_paths', 'sfepy.get_paths', (['"""sfepy/solvers/*.py"""'], {}), "('sfepy/solvers/*.py')\n", (202, 224), False, 'import sfepy\n'), ((398, 554), 'sfepy.base.base.load_classes', 'load_classes', (['solver_files', '[LinearSolver, NonlinearSolver, TimeSteppingSolver, EigenvalueSolver,\n Optimizatio... |
# Copyright (c) Megvii, Inc. and its affiliates.
import megengine as mge
import megengine.functional as F
import megengine.module as M
from .resnet import BasicBlock
class STN(M.Module):
"""spatial transformer networks from
`"Spatial Transformer Networks" <https://arxiv.org/pdf/1506.02025.pdf>`_
some de... | [
"megengine.functional.broadcast_to",
"megengine.functional.flatten",
"megengine.module.ReLU",
"megengine.tensor",
"megengine.module.MaxPool2d",
"megengine.functional.matmul",
"megengine.module.Conv2d",
"megengine.functional.warp_perspective",
"megengine.module.Linear",
"megengine.module.BatchNorm2... | [((944, 959), 'megengine.module.Linear', 'M.Linear', (['(64)', '(9)'], {}), '(64, 9)\n', (952, 959), True, 'import megengine.module as M\n'), ((1452, 1493), 'megengine.functional.warp_perspective', 'F.warp_perspective', (['image', 'mat3x3', '[s, s]'], {}), '(image, mat3x3, [s, s])\n', (1470, 1493), True, 'import megeng... |
from sqlmodel import Session, select
from sqlalchemy.orm import joinedload
from .models import Pessoa, Livro, engine
def create_livros(titulo: str, pessoa_id: int):
livro = Livro(titulo=titulo, pessoa_id=pessoa_id)
with Session(engine) as session:
session.add(livro)
session.commit()
s... | [
"sqlmodel.select",
"sqlmodel.Session"
] | [((878, 892), 'sqlmodel.select', 'select', (['Pessoa'], {}), '(Pessoa)\n', (884, 892), False, 'from sqlmodel import Session, select\n'), ((231, 246), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (238, 246), False, 'from sqlmodel import Session, select\n'), ((413, 428), 'sqlalchemy.orm.joinedload', 'jo... |
from sqlmodel import create_engine, SQLModel, Session
sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"
connect_args = {"check_same_thread": False}
engine = create_engine(sqlite_url, echo=True, connect_args=connect_args)
def init_db():
SQLModel.metadata.create_all(engine)
def get_... | [
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.create_engine"
] | [((188, 251), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)', 'connect_args': 'connect_args'}), '(sqlite_url, echo=True, connect_args=connect_args)\n', (201, 251), False, 'from sqlmodel import create_engine, SQLModel, Session\n'), ((273, 309), 'sqlmodel.SQLModel.metadata.create_all', 'SQL... |
from sqlalchemy import inspect
from sqlalchemy.engine.reflection import Inspector
from sqlmodel import create_engine
def test_create_db_and_table(clear_sqlmodel):
from docs_src.tutorial.create_db_and_table import tutorial003 as mod
mod.sqlite_url = "sqlite://"
mod.engine = create_engine(mod.sqlite_url)
... | [
"sqlmodel.create_engine"
] | [((289, 318), 'sqlmodel.create_engine', 'create_engine', (['mod.sqlite_url'], {}), '(mod.sqlite_url)\n', (302, 318), False, 'from sqlmodel import create_engine\n'), ((323, 349), 'docs_src.tutorial.create_db_and_table.tutorial003.create_db_and_tables', 'mod.create_db_and_tables', ([], {}), '()\n', (347, 349), True, 'fro... |
# -*- coding: utf-8 -*-
"""
Fields for Discontinous Galerkin method
"""
import numpy as nm
import six
from numpy.lib.stride_tricks import as_strided
from six.moves import range
from sfepy.base.base import (output, assert_, Struct)
from sfepy.discrete import Integral, PolySpace
from sfepy.discrete.common.fields import ... | [
"sfepy.discrete.fem.mappings.VolumeMapping",
"sfepy.base.base.Struct.__init__",
"sfepy.discrete.Integral",
"sfepy.base.base.Struct",
"sfepy.discrete.common.fields.parse_shape",
"sfepy.discrete.PolySpace.any_from_args"
] | [((3017, 3054), 'six.iteritems', 'six.iteritems', (['region.domain.geom_els'], {}), '(region.domain.geom_els)\n', (3030, 3054), False, 'import six\n'), ((1255, 1369), 'numpy.lib.stride_tricks.as_strided', 'as_strided', (['u'], {'shape': '(n_cell, n_el_nod, 1)', 'strides': '(n_el_nod * ustride1, ustride1, ustride1)', 'w... |
from typing import Optional
from sqlmodel import Field, SQLModel
from datetime import datetime
class Calendar(SQLModel, table=True):
"""Create an SQLModel for a calendar"""
id: Optional[int] = Field(default=None, primary_key=True)
date: datetime
year_number: int
year_name: str
quarter_number:... | [
"sqlmodel.Field"
] | [((204, 241), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (209, 241), False, 'from sqlmodel import Field, SQLModel\n')] |
import numpy as np
from megengine import Tensor
import megengine.functional as F
import pdb
class AnchorGenerator():
"""default anchor generator for fpn.
This class generate anchors by feature map in level.
"""
def __init__(self, base_size=16, ratios=[0.5, 1, 2],
base_scale=2):
self.base... | [
"megengine.functional.linspace",
"megengine.Tensor",
"megengine.functional.stack",
"megengine.functional.sqrt",
"megengine.functional.expand_dims",
"megengine.functional.concat"
] | [((364, 384), 'numpy.array', 'np.array', (['base_scale'], {}), '(base_scale)\n', (372, 384), True, 'import numpy as np\n'), ((939, 993), 'megengine.Tensor', 'Tensor', (['[0, 0, self.base_size - 1, self.base_size - 1]'], {}), '([0, 0, self.base_size - 1, self.base_size - 1])\n', (945, 993), False, 'from megengine import... |
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.module as M
import megengine.optimizer as optim
class AdaptiveAvgPool2d(M.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return F.mean(F.mean(x, axis=-2, keepdims=True), axis=-1... | [
"megengine.module.Sigmoid",
"megengine.module.ReLU",
"megengine.functional.mean",
"megengine.functional.max",
"megengine.module.Conv2d"
] | [((933, 944), 'megengine.module.Sigmoid', 'M.Sigmoid', ([], {}), '()\n', (942, 944), True, 'import megengine.module as M\n'), ((1239, 1289), 'megengine.module.Conv2d', 'M.Conv2d', (['(2)', '(1)', 'kernel_size'], {'padding': '(1)', 'bias': '(False)'}), '(2, 1, kernel_size, padding=1, bias=False)\n', (1247, 1289), True, ... |
#!/usr/bin/env python
# This code was adapted from http://sfepy.org/doc-devel/mat_optim.html.
from __future__ import print_function
from __future__ import absolute_import
import sys
sys.path.append('.')
import matplotlib as mlp
import matplotlib.pyplot as plt
from matplotlib.collections import PolyCollection
from mp... | [
"sfepy.base.conf.get_standard_keywords",
"sfepy.base.base.output.set_output",
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.base.base.Struct",
"sfepy.homogenization.homogen_app.HomogenizationApp",
"sfepy.applications.PDESolverApp"
] | [((184, 204), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (199, 204), False, 'import sys\n'), ((7258, 7293), 'numpy.array', 'np.array', (['[x0[0], 0.45, x0[1], 0.0]'], {}), '([x0[0], 0.45, x0[1], 0.0])\n', (7266, 7293), True, 'import numpy as np\n'), ((7662, 7697), 'numpy.array', 'np.array', (['... |
from typing import TYPE_CHECKING, Union
from uuid import UUID
from sqlalchemy.schema import Column, ForeignKey, UniqueConstraint
from sqlmodel import Field, Relationship
from sqlmodel.sql.sqltypes import GUID
from joj.horse.models.base import BaseORMModel
from joj.horse.models.domain import Domain
from joj.horse.mode... | [
"sqlmodel.Relationship"
] | [((883, 919), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""users"""'}), "(back_populates='users')\n", (895, 919), False, 'from sqlmodel import Field, Relationship\n'), ((1086, 1129), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""domain_users"""'}), "(back_populates='domain... |
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.core.tensor.utils.subgraph_fn",
"megengine.device.CompNode",
"megengine.jit.trace",
"megengine.device.get_default_device",
"megengine.core.ops.builtin.Reduce",
"megengine.tensor",
"megengine.core.ops.builtin.TypeCvt",
"megengine.autodiff.grad_mana... | [((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... |
from __future__ import absolute_import
import hashlib
import numpy as nm
import warnings
import scipy.sparse as sps
import six
from six.moves import range
warnings.simplefilter('ignore', sps.SparseEfficiencyWarning)
from sfepy.base.base import output, get_default, assert_, try_imports
from sfepy.base.timing import ... | [
"sfepy.solvers.solvers.LinearSolver.__init__",
"sfepy.solvers.ls_mumps.load_mumps_libraries",
"sfepy.base.conf.get_standard_keywords",
"sfepy.base.base.output",
"sfepy.base.base.assert_",
"sfepy.discrete.Problem.from_conf",
"sfepy.base.base.get_default",
"sfepy.base.base.output.set_output_prefix",
"... | [((158, 218), 'warnings.simplefilter', 'warnings.simplefilter', (['"""ignore"""', 'sps.SparseEfficiencyWarning'], {}), "('ignore', sps.SparseEfficiencyWarning)\n", (179, 218), False, 'import warnings\n'), ((617, 655), 'sfepy.base.base.get_default', 'get_default', (['solver_class', 'ScipyDirect'], {}), '(solver_class, S... |
# -*- coding: utf-8 -*-
import megengine as mge
import megengine.random as rand
import megengine.functional as F
import numpy as np
from config import config
from det_opr.bbox_opr import box_overlap_opr, bbox_transform_opr, box_overlap_ignore_opr
import pdb
def fpn_roi_target(rpn_rois, im_info, gt_boxes, fg_threshold ... | [
"megengine.functional.gather",
"megengine.functional.minimum",
"megengine.functional.argsort",
"megengine.tensor",
"megengine.functional.cond_take",
"megengine.random.uniform",
"megengine.functional.equal",
"megengine.functional.expand_dims",
"megengine.functional.concat",
"megengine.functional.on... | [((6507, 6535), 'megengine.functional.equal', 'F.equal', (['masks', 'sample_value'], {}), '(masks, sample_value)\n', (6514, 6535), True, 'import megengine.functional as F\n'), ((6593, 6625), 'megengine.functional.minimum', 'F.minimum', (['num_mask', 'num_samples'], {}), '(num_mask, num_samples)\n', (6602, 6625), True, ... |
"""Arquivo para fixtures"""
from unittest.mock import patch
from pytest import fixture
from sqlmodel import create_engine, SQLModel
from tests.mocks import mock_user
from mitmirror.infra.entities import * # pylint: disable=W0614, W0401
user = mock_user()
@fixture(scope="module")
def fake_user():
"""Mock de usu... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.create_engine"
] | [((246, 257), 'tests.mocks.mock_user', 'mock_user', ([], {}), '()\n', (255, 257), False, 'from tests.mocks import mock_user\n'), ((261, 284), 'pytest.fixture', 'fixture', ([], {'scope': '"""module"""'}), "(scope='module')\n", (268, 284), False, 'from pytest import fixture\n'), ((348, 387), 'pytest.fixture', 'fixture', ... |
from typing import Optional
from fastapi import FastAPI
from sqlalchemy.sql.expression import table
from sqlmodel import (
SQLModel,
Field,
create_engine,
select,
Session
)
engine = create_engine('sqlite:///database.db')
class Pessoa(SQLModel, table=True):
id : Optional[int] = Field(default=N... | [
"sqlmodel.create_engine",
"sqlmodel.select",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field"
] | [((204, 242), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite:///database.db"""'], {}), "('sqlite:///database.db')\n", (217, 242), False, 'from sqlmodel import SQLModel, Field, create_engine, select, Session\n'), ((373, 409), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], ... |
# Copyright (c) 2020 <NAME>
# This code is licensed under MIT license
# (https://github.com/kwotsin/mimicry/blob/master/LICENSE)
# ------------------------------------------------------------------------------
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2021 Megv... | [
"megengine.functional.sqrt",
"megengine.functional.mean",
"megengine.jit.trace",
"megengine.functional.clamp",
"megengine.functional.avg_pool2d"
] | [((2715, 2747), 'megengine.functional.mean', 'F.mean', (['x'], {'axis': '(1)', 'keepdims': '(True)'}), '(x, axis=1, keepdims=True)\n', (2721, 2747), True, 'import megengine.functional as F\n'), ((2756, 2799), 'megengine.functional.mean', 'F.mean', (['((x - m) ** 2)'], {'axis': '(1)', 'keepdims': '(True)'}), '((x - m) *... |
from datetime import datetime
from sqlmodel import Field, SQLModel, Relationship, Column, DateTime
from app.models.links import LinkGroupUser
from typing import List, Optional
from pydantic import EmailStr
from app.models.base_uuid_model import BaseUUIDModel
from uuid import UUID
class UserBase(SQLModel):
first_na... | [
"sqlmodel.Field",
"sqlmodel.DateTime",
"sqlmodel.Relationship"
] | [((369, 436), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)', 'index': '(True)', 'sa_column_kwargs': "{'unique': True}"}), "(nullable=True, index=True, sa_column_kwargs={'unique': True})\n", (374, 436), False, 'from sqlmodel import Field, SQLModel, Relationship, Column, DateTime\n'), ((463, 482), 'sqlmodel.Field... |
from typing import TYPE_CHECKING, Any, Dict, Optional, Union
from uuid import UUID, uuid4
from pydantic import PositiveFloat, validator
from sqlmodel import Column, Field, Relationship, SQLModel
from sqlmodel.sql.sqltypes import GUID
if TYPE_CHECKING:
from .user import User
class BaseItem(SQLModel):
code: s... | [
"sqlmodel.sql.sqltypes.GUID",
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((325, 369), 'sqlmodel.Field', 'Field', ([], {'description': '"""Item code"""', 'min_length': '(1)'}), "(description='Item code', min_length=1)\n", (330, 369), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((386, 430), 'sqlmodel.Field', 'Field', ([], {'description': '"""Item Name"""', 'min_le... |
# -*- 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.get_logger",
"megengine.distributed.get_rank",
"megengine.data.DataLoader",
"megengine.tensor",
"megengine.distributed.launcher",
"megengine.load"
] | [((691, 715), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (705, 715), True, 'import megengine as mge\n'), ((774, 799), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (797, 799), False, 'import argparse\n'), ((1656, 1683), 'official.vision.detection.tools.utils.... |
from sfepy.base.base import Struct
from sfepy.solvers import Solver
class MassOperator(Struct):
"""
Encapsulation of action and inverse action of a mass matrix operator
:math:`M`.
"""
def __init__(self, problem, options):
self.mtx_mass = problem.evaluate(options.mass, mode='weak',
... | [
"sfepy.solvers.Solver.any_from_conf"
] | [((559, 630), 'sfepy.solvers.Solver.any_from_conf', 'Solver.any_from_conf', (['problem.ls_conf'], {'mtx': 'self.mtx_mass', 'presolve': '(True)'}), '(problem.ls_conf, mtx=self.mtx_mass, presolve=True)\n', (579, 630), False, 'from sfepy.solvers import Solver\n')] |
import typing as t
from sqlmodel import Field, SQLModel
class Quotes(SQLModel, table=True):
id: t.Optional[int] = Field(default=None, primary_key=True)
quote: str
| [
"sqlmodel.Field"
] | [((121, 158), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (126, 158), False, 'from sqlmodel import Field, SQLModel\n')] |
#!/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.base.base.nm.eye",
"sfepy.base.base.nm.repeat",
"sfepy.discrete.fem.meshio.output_mesh_formats",
"sfepy.discrete.fem.Mesh.from_region",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.fem.FEDomain",
"sfepy.base.base.output",
"sfepy.discrete.fem.Mesh.from_data",
"sfepy.base.base.nm.array"... | [((665, 685), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (680, 685), False, 'import sys\n'), ((3246, 3331), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '__doc__', 'formatter_class': 'RawDescriptionHelpFormatter'}), '(description=__doc__, formatter_class=RawDescriptionHelpF... |
from sqlmodel import SQLModel, create_engine
from sqlalchemy.orm import sessionmaker
from opencensus.ext.azure.log_exporter import AzureLogHandler
from sfm.logger import create_logger
from sfm.config import get_settings
import psycopg2
# def generate_db_string(ENV: str, DBHOST: str, DBNAME: str, DBUSER: str, DBPASS: ... | [
"sqlmodel.create_engine"
] | [((1212, 1226), 'sfm.config.get_settings', 'get_settings', ([], {}), '()\n', (1224, 1226), False, 'from sfm.config import get_settings\n'), ((1671, 1694), 'sfm.logger.create_logger', 'create_logger', (['__name__'], {}), '(__name__)\n', (1684, 1694), False, 'from sfm.logger import create_logger\n'), ((1705, 1757), 'sqlm... |
from sfepy.terms.terms import *
from sfepy.linalg import dot_sequences
class NonPenetrationTerm(Term):
r"""
:Description:
Non-penetration condition in the weak sense.
:Definition:
.. math::
\int_{\Gamma} \lambda \ul{n} \cdot \ul{v} \mbox{ , }
\int_{\Gamma} \hat\lambda \ul{n} \cdot ... | [
"sfepy.linalg.dot_sequences"
] | [((2897, 2941), 'sfepy.linalg.dot_sequences', 'dot_sequences', (['ebf_t', 'normals'], {'use_rows': '(True)'}), '(ebf_t, normals, use_rows=True)\n', (2910, 2941), False, 'from sfepy.linalg import dot_sequences\n'), ((2393, 2432), 'sfepy.linalg.dot_sequences', 'dot_sequences', (['ebf_t', 'nl'], {'use_rows': '(True)'}), '... |
from typing import List
from uuid import UUID
import inject
from sqlmodel import Session, select
from src.core.events import EventDescription
from src.core.helpers.exceptions import DatabaseError, NotAuthorizedError, NotFoundError
from src.core.models import Client, Context, CreateClient, QueryClient, UpdateClient
fr... | [
"sqlmodel.select"
] | [((360, 392), 'inject.params', 'inject.params', ([], {'streamer': 'Streamer'}), '(streamer=Streamer)\n', (373, 392), False, 'import inject\n'), ((1819, 1851), 'inject.params', 'inject.params', ([], {'streamer': 'Streamer'}), '(streamer=Streamer)\n', (1832, 1851), False, 'import inject\n'), ((2500, 2532), 'inject.params... |
from sqlmodel import Field, SQLModel
from pydantic import EmailStr
from fastapi_utils.guid_type import GUID, GUID_DEFAULT_SQLITE
import uuid
class User(SQLModel, table=True):
id: str = Field(default=str(GUID_DEFAULT_SQLITE()))
email: EmailStr = Field(primary_key=True)
firstName: str
lastName: str
... | [
"sqlmodel.Field"
] | [((254, 277), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (259, 277), False, 'from sqlmodel import Field, SQLModel\n'), ((208, 229), 'fastapi_utils.guid_type.GUID_DEFAULT_SQLITE', 'GUID_DEFAULT_SQLITE', ([], {}), '()\n', (227, 229), False, 'from fastapi_utils.guid_type import GUI... |
import importlib
import pytest
from fastapi.testclient import TestClient
from sqlalchemy import inspect
from sqlalchemy.engine.reflection import Inspector
from sqlmodel import Session, create_engine
from docs_src.tutorial.fastapi.app_testing.tutorial001 import main as app_mod
from docs_src.tutorial.fastapi.app_testin... | [
"sqlmodel.create_engine"
] | [((618, 662), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""prepare"""', 'autouse': '(True)'}), "(name='prepare', autouse=True)\n", (632, 662), False, 'import pytest\n'), ((899, 924), 'importlib.reload', 'importlib.reload', (['app_mod'], {}), '(app_mod)\n', (915, 924), False, 'import importlib\n'), ((929, 955),... |
from pydantic import BaseModel
from sqlmodel import Field, SQLModel, Relationship
from typing import Optional, List
class UserBase(SQLModel):
username: str
desc: str
class User(UserBase, table=True):
id: Optional[int] = Field(index=True, default=None, primary_key=True)
password: str
tasks: List["... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((235, 284), 'sqlmodel.Field', 'Field', ([], {'index': '(True)', 'default': 'None', 'primary_key': '(True)'}), '(index=True, default=None, primary_key=True)\n', (240, 284), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((329, 365), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""... |
# -*- coding: utf-8 -*-
import megengine.module as M
import megengine.functional as F
class LeNet32x32(M.Module):
def __init__(self):
super().__init__()
# single channel image, two 5x5 Conv + ReLU + Pool
# Conv2d(1, 6, kernel_size=(5, 5))
self.conv1 = M.Conv2d(1, 6, 5)
self.... | [
"megengine.module.MaxPool2d",
"megengine.module.Linear",
"megengine.module.ReLU",
"megengine.module.Conv2d",
"megengine.functional.flatten"
] | [((289, 306), 'megengine.module.Conv2d', 'M.Conv2d', (['(1)', '(6)', '(5)'], {}), '(1, 6, 5)\n', (297, 306), True, 'import megengine.module as M\n'), ((328, 336), 'megengine.module.ReLU', 'M.ReLU', ([], {}), '()\n', (334, 336), True, 'import megengine.module as M\n'), ((414, 431), 'megengine.module.MaxPool2d', 'M.MaxPo... |
from sqlmodel import SQLModel, Field
import datetime
from typing import Optional
class Orders(SQLModel, table=True):
invoice_no: Optional[int] = Field(default=None, primary_key=True)
stock_code: str
description: str
quantity: int
invoice_date: datetime.datetime
unit_price: float
cust_id: i... | [
"sqlmodel.Field"
] | [((151, 188), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (156, 188), False, 'from sqlmodel import SQLModel, Field\n')] |
import contextlib
import os
import pathlib
import hypothesis.strategies as st
import pytest
import strawberry
from hypothesis.strategies import SearchStrategy
from sqlalchemy.pool import StaticPool
from sqlmodel import Session, SQLModel, create_engine
from starlette.testclient import TestClient
from fastapi_server.da... | [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all"
] | [((5233, 5277), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""method_client_fixture"""'}), "(name='method_client_fixture')\n", (5247, 5277), False, 'import pytest\n'), ((5483, 5528), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""example_client_fixture"""'}), "(name='example_client_fixture')\n", (5497, 5... |
from datetime import datetime
from typing import TYPE_CHECKING, List, Optional
from uuid import UUID, uuid4
from pydantic import EmailStr, constr, validator
from sqlmodel import Column, Field, Relationship, SQLModel
from sqlmodel.sql.sqltypes import GUID
from ...utils.date import now_datetime
if TYPE_CHECKING:
f... | [
"sqlmodel.Field",
"sqlmodel.sql.sqltypes.GUID",
"sqlmodel.Relationship"
] | [((417, 449), 'sqlmodel.Field', 'Field', ([], {'description': '"""Client name"""'}), "(description='Client name')\n", (422, 449), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((482, 530), 'sqlmodel.Field', 'Field', ([], {'description': '"""Client email"""', 'nullable': '(True)'}), "(descripti... |
from typing import List, Optional
from sqlmodel import Field, Session, SQLModel, create_engine
class Zi(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str = Field(...)
stroke_count: int = Field(...)
strokes: str = Field(...)
heng_count: int = Fiel... | [
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.create_engine",
"sqlmodel.Field"
] | [((474, 564), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite:///Data/strokes.db"""'], {'connect_args': "{'check_same_thread': False}"}), "('sqlite:///Data/strokes.db', connect_args={\n 'check_same_thread': False})\n", (487, 564), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((56... |
# 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.qint32",
"megengine._internal.dtype.get_scale"
] | [((958, 988), 'megengine._internal.dtype.get_scale', 'mgb.dtype.get_scale', (['inp.dtype'], {}), '(inp.dtype)\n', (977, 988), True, 'import megengine._internal as mgb\n'), ((1007, 1045), 'megengine._internal.dtype.get_scale', 'mgb.dtype.get_scale', (['self.weight.dtype'], {}), '(self.weight.dtype)\n', (1026, 1045), Tru... |
from sqlmodel import SQLModel, Relationship
from typing import List
from app.models.base_uuid_model import BaseUUIDModel
class RoleBase(SQLModel):
name: str
description: str
class Role(BaseUUIDModel, RoleBase, table=True):
users: List["User"] = Relationship(back_populates="role", sa_relationship_kwarg... | [
"sqlmodel.Relationship"
] | [((263, 348), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""role"""', 'sa_relationship_kwargs': "{'lazy': 'selectin'}"}), "(back_populates='role', sa_relationship_kwargs={'lazy': 'selectin'}\n )\n", (275, 348), False, 'from sqlmodel import SQLModel, Relationship\n')] |
from enum import Enum
from typing import TYPE_CHECKING, Optional
from sqlalchemy import Column
from sqlalchemy import Enum as SQLEnum
from sqlalchemy import ForeignKey, Integer
from sqlmodel import Field, Relationship, SQLModel
if TYPE_CHECKING:
from .message import Message, MessageList
class MessageTriggerType... | [
"sqlmodel.Relationship"
] | [((1182, 1196), 'sqlmodel.Relationship', 'Relationship', ([], {}), '()\n', (1194, 1196), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((757, 784), 'sqlalchemy.Enum', 'SQLEnum', (['MessageTriggerType'], {}), '(MessageTriggerType)\n', (764, 784), True, 'from sqlalchemy import Enum as SQLEnum\n'), ((103... |
from datetime import datetime, timezone
from typing import List, Optional
from sqlmodel import Field, Relationship, SQLModel, Session, select
from sqlalchemy.engine import Engine
class Post(SQLModel, table=True):
__tablename__ = "ig_posts"
id: Optional[int] = Field(default=None, primary_key=True)
ig_acc... | [
"sqlmodel.Relationship",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.select"
] | [((271, 308), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (276, 308), False, 'from sqlmodel import Field, Relationship, SQLModel, Session, select\n'), ((335, 370), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""ig_accounts.id"""'}), "(foreign... |
import re
from copy import copy
import numpy as nm
from sfepy.base.base import (as_float_or_complex, get_default, assert_,
Container, Struct, basestr, goptions)
from sfepy.base.compat import in1d
# Used for imports in term files.
from sfepy.terms.extmods import terms
from sfepy.linalg i... | [
"sfepy.base.base.Container.append",
"sfepy.base.base.Struct",
"sfepy.terms.extmods.terms.append",
"sfepy.terms.term_table.keys",
"sfepy.base.base.get_default",
"sfepy.discrete.Integrals",
"sfepy.terms.extmods.terms.errclear",
"sfepy.base.base.Container.insert",
"sfepy.linalg.split_range",
"sfepy.d... | [((353, 391), 're.compile', 're.compile', (['"""^([^\\\\(\\\\}]*)\\\\((.*)\\\\)$"""'], {}), "('^([^\\\\(\\\\}]*)\\\\((.*)\\\\)$')\n", (363, 391), False, 'import re\n'), ((411, 434), 're.compile', 're.compile', (['"""^virtual$"""'], {}), "('^virtual$')\n", (421, 434), False, 'import re\n'), ((456, 494), 're.compile', 'r... |
from sfepy.base.testing import TestCommon, assert_, debug
class Test(TestCommon):
@staticmethod
def from_conf(conf, options):
return Test(conf=conf, options=options)
def test_tensors(self):
import numpy as nm
from sfepy.mechanics.matcoefs import ElasticConstants
ok = True... | [
"sfepy.mechanics.matcoefs.ElasticConstants"
] | [((404, 437), 'sfepy.mechanics.matcoefs.ElasticConstants', 'ElasticConstants', ([], {'lam': '(1.0)', 'mu': '(1.5)'}), '(lam=1.0, mu=1.5)\n', (420, 437), False, 'from sfepy.mechanics.matcoefs import ElasticConstants\n'), ((908, 934), 'numpy.allclose', 'nm.allclose', (['ec_vals', 'vals'], {}), '(ec_vals, vals)\n', (919, ... |
# 28.05.2009, c
from sfepy import data_dir
filename_mesh = data_dir + '/meshes/3d/elbow.mesh'
fields = {
'scalar' : ('real', 'scalar', 'Omega', 1),
'vector' : ('real', 'vector', 'Omega', 1),
}
integrals = {
'i1' : ('v', 'gauss_o2_d3'),
'i2' : ('s', 'gauss_o2_d2'),
}
regions = {
'Omega' : ('all',... | [
"sfepy.fem.FieldVariable",
"sfepy.fem.ProblemDefinition.from_conf"
] | [((910, 965), 'sfepy.fem.ProblemDefinition.from_conf', 'ProblemDefinition.from_conf', (['conf'], {'init_equations': '(False)'}), '(conf, init_equations=False)\n', (937, 965), False, 'from sfepy.fem import ProblemDefinition\n'), ((1465, 1550), 'sfepy.fem.FieldVariable', 'FieldVariable', (['var_name', '"""parameter"""', ... |
from flask import Blueprint
from flask import request
from flask import jsonify
from flask import session
from flask import current_app
from flask import render_template
from flask import request
from app.utils import render_markdown
from sqlmodel import Session as SQLSession
from sqlmodel import select
from app.model... | [
"sqlmodel.select",
"sqlmodel.Session"
] | [((413, 441), 'flask.Blueprint', 'Blueprint', (['"""admin"""', '__name__'], {}), "('admin', __name__)\n", (422, 441), False, 'from flask import Blueprint\n'), ((499, 561), 'app.utils.render_markdown', 'render_markdown', (['"""page.html"""'], {'file': '"""admin.md"""', 'session': 'session'}), "('page.html', file='admin.... |
"""add remoteuser
Revision ID: 5c6d07e2a9c1
Revises: <KEY>
Create Date: 2022-02-13 01:54:01.310088
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = '5c6d07e2a9c1'
down_revision = '<KEY>'
branch_labels = None
depends_on = None
def upgrade():
... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((880, 907), 'alembic.op.drop_table', 'op.drop_table', (['"""remoteuser"""'], {}), "('remoteuser')\n", (893, 907), False, 'from alembic import op\n'), ((683, 712), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""id"""'], {}), "('id')\n", (706, 712), True, 'import sqlalchemy as sa\n'), ((718, 749), ... |
#!/usr/bin/env python
"""
First solve the stationary electric conduction problem. Then use its
results to solve the evolutionary heat conduction problem.
Run this example as on a command line::
$ python <path_to_this_file>/thermal_electric.py
"""
from __future__ import absolute_import
import sys
sys.path.append( ... | [
"sfepy.discrete.Problem.from_conf",
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.base.conf.get_standard_keywords"
] | [((303, 323), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (318, 323), False, 'import sys\n'), ((697, 724), 'os.path.join', 'os.path.join', (['cwd', '"""output"""'], {}), "(cwd, 'output')\n", (709, 724), False, 'import os\n'), ((3013, 3036), 'sfepy.base.conf.get_standard_keywords', 'get_standard_... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import os
from typing import List
import megengine.distributed as dist
from basecore.config import ConfigDict
from basecore.engine import BaseHook
from basecore.utils import str_timestamp
from basecls.utils import registers
from .hooks... | [
"megengine.distributed.get_rank"
] | [((490, 516), 'basecls.utils.registers.hooks.register', 'registers.hooks.register', ([], {}), '()\n', (514, 516), False, 'from basecls.utils import registers\n'), ((1367, 1382), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (1380, 1382), True, 'import megengine.distributed as dist\n'), ((1611, 16... |
from sqlmodel import SQLModel, Field
import uuid as uuid_pkg
from typing import Optional
class FilesBase(SQLModel):
name: str
class Files(FilesBase, table=True):
id: int = Field(default=None, primary_key=True)
uuid: uuid_pkg.UUID = Field(
default_factory=uuid_pkg.uuid4,
index=True,
... | [
"sqlmodel.Field"
] | [((184, 221), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (189, 221), False, 'from sqlmodel import SQLModel, Field\n'), ((248, 313), 'sqlmodel.Field', 'Field', ([], {'default_factory': 'uuid_pkg.uuid4', 'index': '(True)', 'nullable': '(False)'}), ... |
from datetime import date
from typing import List, Optional
from api.ecoindex.models.responses import ApiEcoindex
from api.models.enums import Version
from sqlalchemy.ext.asyncio.session import AsyncSession
from sqlmodel import select
from db.helper import date_filter
async def get_host_list_db(
session: AsyncS... | [
"sqlmodel.select"
] | [((704, 774), 'db.helper.date_filter', 'date_filter', ([], {'statement': 'statement', 'date_from': 'date_from', 'date_to': 'date_to'}), '(statement=statement, date_from=date_from, date_to=date_to)\n', (715, 774), False, 'from db.helper import date_filter\n'), ((508, 532), 'sqlmodel.select', 'select', (['ApiEcoindex.hos... |
import json
import requests
import base64, hashlib, hmac, time
import email.utils
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
from urllib.parse import urlparse
from db.db import async_session
from models.users import RemoteUser
from sqlm... | [
"sqlmodel.select"
] | [((1382, 1401), 'urllib.parse.urlparse', 'urlparse', (['target_id'], {}), '(target_id)\n', (1390, 1401), False, 'from urllib.parse import urlparse\n'), ((1411, 1427), 'hashlib.sha256', 'hashlib.sha256', ([], {}), '()\n', (1425, 1427), False, 'import base64, hashlib, hmac, time\n'), ((2347, 2395), 'requests.post', 'requ... |
import argparse
import logging
import os
import dataset.data_loader as data_loader
import model.net as net
from common import utils
from loss.losses import compute_losses, compute_metrics
from common.manager import Manager
import megengine.distributed as dist
import megengine.functional as F
parser = argparse.Argum... | [
"megengine.functional.distributed.all_reduce_sum",
"megengine.distributed.get_world_size",
"megengine.distributed.get_rank"
] | [((306, 331), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (329, 331), False, 'import argparse\n'), ((606, 621), 'megengine.distributed.get_rank', 'dist.get_rank', ([], {}), '()\n', (619, 621), True, 'import megengine.distributed as dist\n'), ((639, 660), 'megengine.distributed.get_world_size... |
# -*- 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.sign",
"megengine.functional.elemwise.Elemwise",
"megengine.core.tensor.dtype.qint8",
"megengine.functional.logical_not",
"megengine.jit.trace",
"megengine.tensor",
"megengine.functional.logical_xor",
"megengine.functional.logical_or",
"megengine.functional.mul",
"megengine.f... | [((6757, 6807), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""is_trace"""', '[True, False]'], {}), "('is_trace', [True, False])\n", (6780, 6807), False, 'import pytest\n'), ((2580, 2615), 'numpy.linspace', 'np.linspace', (['(-6)', '(6)'], {'dtype': '"""float32"""'}), "(-6, 6, dtype='float32')\n", (2591, 2... |
from fastapi import *
from sqlmodel import Session, select, SQLModel
from sqlalchemy.exc import OperationalError
from backend.models.timelog import TimeLog
from backend.models.calendar import Calendar
from backend.utils import (
engine,
sqlite3_engine,
create_db,
tags_metadata,
execute_sample_sql,
)... | [
"sqlmodel.Session",
"sqlmodel.select"
] | [((583, 598), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (590, 598), False, 'from sqlmodel import Session, select, SQLModel\n'), ((1080, 1095), 'sqlmodel.select', 'select', (['TimeLog'], {}), '(TimeLog)\n', (1086, 1095), False, 'from sqlmodel import Session, select, SQLModel\n'), ((1175, 1186), 'bac... |
import megengine as mge
import megengine.module as M
from megengine import functional as F
import numpy as np
from .transformer import MultiheadAttention
#from .utility import has_nan_or_inf
# mge.core.set_option('async_level', 0)
class DecoderWrapper(M.Module):
def __init__(self, cfg):
super().__init__()... | [
"megengine.module.Linear"
] | [((590, 643), 'megengine.module.Linear', 'M.Linear', ([], {'in_features': 'channels', 'out_features': 'channels'}), '(in_features=channels, out_features=channels)\n', (598, 643), True, 'import megengine.module as M\n')] |
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.module as M
import math
from config import config
from backbone.resnet50 import ResNet50
from module.generate_anchors import generate_anchors
from det_opr.bbox_opr import bbox_transform_inv_opr, box_overlap_opr
from det_opr.uti... | [
"megengine.module.init.fill_",
"megengine.module.ReLU",
"megengine.functional.sigmoid",
"megengine.functional.ones",
"megengine.module.Conv2d",
"megengine.functional.expand_dims",
"megengine.functional.nn.interpolate",
"megengine.functional.stack",
"megengine.functional.concat",
"megengine.functio... | [((1393, 1470), 'megengine.functional.stack', 'F.stack', (['[broad_shift_x, broad_shift_y, broad_shift_x, broad_shift_y]'], {'axis': '(1)'}), '([broad_shift_x, broad_shift_y, broad_shift_x, broad_shift_y], axis=1)\n', (1400, 1470), True, 'import megengine.functional as F\n'), ((2352, 2362), 'backbone.resnet50.ResNet50'... |
from typing import Optional
from sqlmodel import Field, Session, SQLModel, create_engine, select
class Team(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str = Field(index=True)
headquarters: str
class Hero(SQLModel, table=True):
id: Optional[int] = Field(de... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.Field",
"sqlmodel.select",
"sqlmodel.create_engine"
] | [((625, 661), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (638, 661), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((158, 195), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=... |
from typing import List
from uuid import UUID
import inject
from sqlalchemy.sql.expression import desc
from sqlmodel import Session, between, select
from src.core.events import EventDescription
from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError
from src.core.models import (... | [
"sqlmodel.select",
"sqlmodel.between"
] | [((1554, 1586), 'inject.params', 'inject.params', ([], {'streamer': 'Streamer'}), '(streamer=Streamer)\n', (1567, 1586), False, 'import inject\n'), ((3515, 3547), 'inject.params', 'inject.params', ([], {'streamer': 'Streamer'}), '(streamer=Streamer)\n', (3528, 3547), False, 'import inject\n'), ((4315, 4347), 'inject.pa... |
import numpy as np
import megengine as mge
import megengine.functional as F
import megengine.module as M
from config import config
from backbone.resnet50 import ResNet50
from module.rpn import RPN
from layers.roi_pool import roi_pool
from det_opr.bbox_opr import bbox_transform_inv_opr, restore_bbox
from det_opr.fpn_roi... | [
"megengine.module.ReLU",
"megengine.functional.softmax",
"megengine.functional.flatten",
"megengine.functional.stack",
"megengine.tensor",
"megengine.module.init.msra_normal_",
"megengine.functional.max_pool2d",
"megengine.functional.concat",
"megengine.module.init.normal_",
"megengine.module.init... | [((656, 666), 'backbone.resnet50.ResNet50', 'ResNet50', ([], {}), '()\n', (664, 666), False, 'from backbone.resnet50 import ResNet50\n'), ((1312, 1335), 'module.rpn.RPN', 'RPN', (['config.rpn_channel'], {}), '(config.rpn_channel)\n', (1315, 1335), False, 'from module.rpn import RPN\n'), ((2306, 2342), 'det_opr.utils.ge... |
# 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"
] | [((1773, 1796), 'dbgen.Model', 'Model', ([], {'name': '"""test_json"""'}), "(name='test_json')\n", (1778, 1796), False, 'from dbgen import Const, Entity, Extract, Generator, Model, Query\n'), ((2054, 2117), 'dbgen.Generator', 'Generator', ([], {'name': '"""load_http_json"""', 'extract': 'extract', 'loads': '[load]'}), ... |
from typing import Optional
from pydantic import EmailStr
from sqlmodel import Field, SQLModel
from sb_backend.app.models.base.base_model import TimeStampMixin
# Shared properties
class UserBase(SQLModel):
email: Optional[EmailStr] = None
is_active: Optional[bool] = True
is_superuser: bool = False
ful... | [
"sqlmodel.Field"
] | [((624, 661), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (629, 661), False, 'from sqlmodel import Field, SQLModel\n')] |
import numpy as nm
from sfepy.base.base import Struct, assert_
from sfepy.discrete.fem.mappings import VolumeMapping, SurfaceMapping
from poly_spaces import PolySpace
from fe_surface import FESurface
def set_mesh_coors(domain, fields, coors, update_fields=False, actual=False,
clear_all=True):
i... | [
"sfepy.mechanics.membranes.create_transformation_matrix",
"sfepy.base.base.Struct",
"sfepy.mechanics.membranes.create_mapping",
"sfepy.discrete.fem.mappings.SurfaceMapping",
"sfepy.linalg.dot_sequences",
"sfepy.base.base.assert_",
"sfepy.discrete.fem.mappings.VolumeMapping"
] | [((1374, 1415), 'numpy.dot', 'nm.dot', (['bf', 'mesh_coors[group.conn[cells]]'], {}), '(bf, mesh_coors[group.conn[cells]])\n', (1380, 1415), True, 'import numpy as nm\n'), ((1435, 1460), 'numpy.swapaxes', 'nm.swapaxes', (['ecoors', '(0)', '(1)'], {}), '(ecoors, 0, 1)\n', (1446, 1460), True, 'import numpy as nm\n'), ((1... |
from fastapi import Path, Depends, HTTPException
from sqlmodel import Session, select
from db import get_db_session
from model.warehouse import Warehouse
from service.base_crud import BaseCRUD
async def validate_warehouse_id(
warehouse_id: int = Path(...),
db_session: Session = Depends(get_db_session... | [
"sqlmodel.select"
] | [((257, 266), 'fastapi.Path', 'Path', (['...'], {}), '(...)\n', (261, 266), False, 'from fastapi import Path, Depends, HTTPException\n'), ((298, 321), 'fastapi.Depends', 'Depends', (['get_db_session'], {}), '(get_db_session)\n', (305, 321), False, 'from fastapi import Path, Depends, HTTPException\n'), ((843, 908), 'fas... |
# -*- coding: utf-8 -*-
# MIT License
#
# Copyright (c) 2019 Megvii Technology
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
#... | [
"megengine.get_device_count",
"megengine.distributed.is_distributed",
"megengine.data.transform.ToMode",
"megengine.data.transform.CenterCrop",
"megengine.data.SequentialSampler",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.get_logger",
"megengine.data.datase... | [((2178, 2202), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (2192, 2202), True, 'import megengine as mge\n'), ((2230, 2255), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2253, 2255), False, 'import argparse\n'), ((5245, 5279), 'os.path.join', 'os.path.join',... |
# Copyright (c) 2014-2022 Megvii Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, eithe... | [
"megengine.module.Dropout",
"megengine.module.Linear",
"megengine.functional.pad",
"megengine.functional.sqrt",
"megengine.module.BatchNorm2d",
"megengine.functional.conv2d",
"megengine.module.AdaptiveAvgPool2d",
"megengine.module.Identity",
"megengine.functional.flatten"
] | [((9027, 9054), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (9052, 9054), False, 'from basecls.utils import registers\n'), ((9190, 9217), 'basecls.utils.registers.models.register', 'registers.models.register', ([], {}), '()\n', (9215, 9217), False, 'from basecls.utils impor... |
import numpy as nm
from sfepy.base.conf import transform_functions
from sfepy.base.testing import TestCommon
def get_vertices(coors, domain=None):
x, z = coors[:,0], coors[:,2]
return nm.where((z < 0.1) & (x < 0.1))[0]
def get_cells(coors, domain=None):
return nm.where(coors[:, 0] < 0)[0]
class Test(Te... | [
"sfepy.base.conf.transform_functions",
"sfepy.discrete.fem.Mesh",
"sfepy.discrete.fem.FEDomain"
] | [((195, 226), 'numpy.where', 'nm.where', (['((z < 0.1) & (x < 0.1))'], {}), '((z < 0.1) & (x < 0.1))\n', (203, 226), True, 'import numpy as nm\n'), ((277, 302), 'numpy.where', 'nm.where', (['(coors[:, 0] < 0)'], {}), '(coors[:, 0] < 0)\n', (285, 302), True, 'import numpy as nm\n'), ((536, 606), 'sfepy.discrete.fem.Mesh... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.tensor",
"megengine.core.tensor.utils.make_shape_tuple",
"megengine.quantization.utils.fake_quant_tensor",
"megengine.quantization.fake_quant.TQT_Function",
"megengine.core.autodiff.grad.Grad"
] | [((2261, 2284), 'megengine.quantization.fake_quant.TQT_Function', 'TQT_Function', (['(-127)', '(127)'], {}), '(-127, 127)\n', (2273, 2284), False, 'from megengine.quantization.fake_quant import TQT_Function\n'), ((2906, 2918), 'megengine.tensor', 'tensor', (['a_np'], {}), '(a_np)\n', (2912, 2918), False, 'from megengin... |
import numpy as np
import argparse
from datetime import datetime
import time
import model as resnet_model
import megengine as mge
import megengine.autodiff as ad
import megengine.functional as F
import megengine.optimizer as optim
parser = argparse.ArgumentParser(description="MegEngine ResNet Training")
parser.add_a... | [
"megengine.functional.nn.cross_entropy",
"megengine.get_mem_status_bytes",
"megengine.utils.dtr.DTR",
"megengine.autodiff.GradManager"
] | [((243, 307), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""MegEngine ResNet Training"""'}), "(description='MegEngine ResNet Training')\n", (266, 307), False, 'import argparse\n'), ((1079, 1125), 'megengine.utils.dtr.DTR', 'DTR', ([], {'memory_budget': '(args.mem_budget * 1024 ** 3)'}),... |
# 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.load"
] | [((1616, 1639), 'megengine.load', 'mge.load', (['traced_module'], {}), '(traced_module)\n', (1624, 1639), True, 'import megengine as mge\n')] |
# Vibroacoustics
#
# E.Rohan, V.Lukeš
# Homogenization of the vibro–acoustic transmission on periodically
# perforated elastic plates with arrays of resonators.
# https://arxiv.org/abs/2104.01367 (arXiv:2104.01367v1)
import os
import numpy as nm
from sfepy.base.base import Struct
from sfepy.homogenization.coefficients... | [
"sfepy.homogenization.coefficients.Coefficients.from_file_hdf5",
"sfepy.discrete.fem.Mesh.from_data",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.fem.FEDomain"
] | [((3633, 3675), 'os.path.join', 'os.path.join', (['pb.output_dir', "(fname + '.h5')"], {}), "(pb.output_dir, fname + '.h5')\n", (3645, 3675), False, 'import os\n'), ((7126, 7147), 'sfepy.discrete.fem.Mesh.from_file', 'Mesh.from_file', (['fname'], {}), '(fname)\n', (7140, 7147), False, 'from sfepy.discrete.fem import Me... |
from typing import Type
from sqlmodel import select, Session
from ..db import engine
from ..models.base import TSQLModelDB
class BaseRepository:
model: Type[TSQLModelDB]
@classmethod
def create(cls, **kwargs) -> TSQLModelDB:
db_model = cls.model(**kwargs)
db_model.save()
return ... | [
"sqlmodel.Session",
"sqlmodel.select"
] | [((445, 460), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (452, 460), False, 'from sqlmodel import select, Session\n'), ((759, 774), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (766, 774), False, 'from sqlmodel import select, Session\n'), ((929, 944), 'sqlmodel.Session', 'Session',... |
import os
import sys
import pytest
from megengine.core._imperative_rt.imperative import sync
sys.path.append(os.path.join(os.path.dirname(__file__), "helpers"))
def pytest_runtest_teardown():
sync()
| [
"megengine.core._imperative_rt.imperative.sync"
] | [((201, 207), 'megengine.core._imperative_rt.imperative.sync', 'sync', ([], {}), '()\n', (205, 207), False, 'from megengine.core._imperative_rt.imperative import sync\n'), ((125, 150), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (140, 150), False, 'import os\n')] |
"""Issuer Database Tables/Models.
Models of the Traction tables for Issuer and related data.
"""
import uuid
from datetime import datetime
from typing import List, Optional
from sqlalchemy.orm import selectinload
from sqlmodel import Field, Relationship
from sqlalchemy import (
Column,
func,
String,
... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((2667, 2742), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""credential_template.credential_template_id"""', 'index': '(True)'}), "(foreign_key='credential_template.credential_template_id', index=True)\n", (2672, 2742), False, 'from sqlmodel import Field, Relationship\n'), ((2784, 2826), 'sqlmodel.Field', 'Field... |
from __future__ import absolute_import
import os
import numpy as nm
from sfepy.base.testing import TestCommon
from sfepy import data_dir
from six.moves import range
# n_vertex, n_edge, n_face, n_cell
# d1 -> d2 : num, n_incident
expected = {
'1_2_2.mesh' : ([3, 2, 0, 0], {
(0, 0) : (3, 4),
(0, 1)... | [
"sfepy.discrete.fem.geometry_element.create_geometry_elements",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.common.Field.from_args",
"sfepy.discrete.Integral",
"sfepy.discrete.common.extmods.cmesh.get_cmem_usage",
"sfepy.discrete.fem.FEDomain"
] | [((2942, 2968), 'sfepy.discrete.fem.geometry_element.create_geometry_elements', 'create_geometry_elements', ([], {}), '()\n', (2966, 2968), False, 'from sfepy.discrete.fem.geometry_element import create_geometry_elements\n'), ((5196, 5271), 'sfepy.discrete.fem.Mesh.from_file', 'Mesh.from_file', (['"""meshes/3d/special/... |
# -*- 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.arange",
"megengine.functional.tile",
"megengine.Tensor",
"megengine.functional.stack",
"megengine.functional.vision.remap",
"megengine.functional.mean",
"megengine.functional.transpose",
"megengine.functional.vision.interpolate",
"megengine.functional.sum"
] | [((3019, 3038), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (3036, 3038), False, 'import logging\n'), ((3078, 3171), 'coloredlogs.install', 'coloredlogs.install', ([], {'level': '"""INFO"""', 'logger': 'logger', 'fmt': '"""%(asctime)s %(name)s %(message)s"""'}), "(level='INFO', logger=logger, fmt=\n ... |
"""Initial
Revision ID: d63ccd5484d7
Revises:
Create Date: 2021-11-14 00:28:55.123695
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = '<KEY>'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto g... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((8907, 8943), 'alembic.op.drop_table', 'op.drop_table', (['"""listingfacilitylink"""'], {}), "('listingfacilitylink')\n", (8920, 8943), False, 'from alembic import op\n'), ((9408, 9431), 'alembic.op.drop_table', 'op.drop_table', (['"""images"""'], {}), "('images')\n", (9421, 9431), False, 'from alembic import op\n'),... |
"""participant id as string
Revision ID: <KEY>
Revises: 11<PASSWORD>3<PASSWORD>
Create Date: 2022-04-04 04:34:56.202331+00:00
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
# revision identifiers, used by Alembic.
revision = "<KEY>"
down_revision = "11505f38b<PASSWORD>"
branch_labels = None
depen... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((420, 514), 'alembic.op.drop_constraint', 'op.drop_constraint', (['"""applications_participant_id_fkey"""', '"""applications"""'], {'type_': '"""foreignkey"""'}), "('applications_participant_id_fkey', 'applications',\n type_='foreignkey')\n", (438, 514), False, 'from alembic import op\n'), ((794, 906), 'alembic.op... |
import os
import numpy as nm
from sfepy.base.testing import TestCommon
from sfepy import data_dir
# n_cell, n_face, n_edge, n_vertex
# d1 -> d2 : num, n_incident
expected = {
'2_3_2.mesh' : ([4, 5, 2, 0], {
(0, 0) : (4, 10),
(0, 1) : (4, 10),
(0, 2) : (4, 6),
(1, 0) : (5, 10),
... | [
"sfepy.discrete.fem.geometry_element.create_geometry_elements",
"sfepy.discrete.fem.extmods.cmesh.CMesh.from_mesh",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.fem.extmods.cmesh.get_cmem_usage"
] | [((2717, 2743), 'sfepy.discrete.fem.geometry_element.create_geometry_elements', 'create_geometry_elements', ([], {}), '()\n', (2741, 2743), False, 'from sfepy.discrete.fem.geometry_element import create_geometry_elements\n'), ((2833, 2859), 'os.path.basename', 'os.path.basename', (['filename'], {}), '(filename)\n', (28... |
from datetime import datetime
from typing import Optional
from sqlmodel import Field, SQLModel
class YouTube(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
video_id: str
title: str
description: str
thumb: str
published: datetime
class YouTubeRead(SQLModel):... | [
"sqlmodel.Field"
] | [((159, 196), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (164, 196), False, 'from sqlmodel import Field, SQLModel\n')] |
from __future__ import absolute_import
input_name = '../examples/multi_physics/piezo_elasticity.py'
output_name = 'test_piezo_elasticity.vtk'
from tests_basic import TestInput
class Test( TestInput ):
def from_conf( conf, options ):
return TestInput.from_conf( conf, options, cls = Test )
from_conf =... | [
"sfepy.discrete.Problem.from_conf"
] | [((256, 300), 'tests_basic.TestInput.from_conf', 'TestInput.from_conf', (['conf', 'options'], {'cls': 'Test'}), '(conf, options, cls=Test)\n', (275, 300), False, 'from tests_basic import TestInput\n'), ((458, 491), 'sfepy.discrete.Problem.from_conf', 'Problem.from_conf', (['self.test_conf'], {}), '(self.test_conf)\n', ... |
from typing import Any
import sqlalchemy.exc
from ariadne import convert_kwargs_to_snake_case
from graphql.type.definition import GraphQLResolveInfo
from graphql_relay.node.node import from_global_id
from sqlmodel import select
from ariadne_example.app.db.session import Session, engine
from ariadne_example.app.core.s... | [
"sqlmodel.select"
] | [((646, 661), 'ariadne_example.app.db.session.Session', 'Session', (['engine'], {}), '(engine)\n', (653, 661), False, 'from ariadne_example.app.db.session import Session, engine\n'), ((701, 724), 'graphql_relay.node.node.from_global_id', 'from_global_id', (['user_id'], {}), '(user_id)\n', (715, 724), False, 'from graph... |
"""
This module is not a test file. It contains classes grouping some common
functionality, that is used in several test files.
"""
from __future__ import absolute_import
from sfepy.base.base import IndexedStruct
from sfepy.base.testing import TestCommon
import os.path as op
class NLSStatus(IndexedStruct):
"""
... | [
"sfepy.base.conf.get_standard_keywords",
"sfepy.applications.assign_standard_hooks",
"sfepy.base.base.IndexedStruct.__setitem__",
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.base.base.Struct",
"sfepy.applications.solve_pde",
"sfepy.base.base.IndexedStruct"
] | [((455, 496), 'sfepy.base.base.IndexedStruct.__setitem__', 'IndexedStruct.__setitem__', (['self', 'key', 'val'], {}), '(self, key, val)\n', (480, 496), False, 'from sfepy.base.base import IndexedStruct\n'), ((1153, 1176), 'sfepy.base.conf.get_standard_keywords', 'get_standard_keywords', ([], {}), '()\n', (1174, 1176), ... |
from typer.testing import CliRunner
import os
from timerdo.main import app, sqlite_file_name
from timerdo.tables import ToDo, Timer
from sqlmodel import create_engine, Session, select
from datetime import datetime, timedelta
try:
os.rename('/home/cmts/.config/timerdo/timerdo_db.db',
'/home/cmts/.co... | [
"sqlmodel.Session",
"sqlmodel.select",
"sqlmodel.create_engine"
] | [((447, 483), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (460, 483), False, 'from sqlmodel import create_engine, Session, select\n'), ((494, 505), 'typer.testing.CliRunner', 'CliRunner', ([], {}), '()\n', (503, 505), False, 'from typer.testing import Cl... |
# -*- 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.module.init.fill_",
"megengine.module.Conv3d",
"megengine.module.Conv1d",
"megengine.module.init.calculate_fan_in_and_fan_out",
"megengine.module.Conv2d",
"megengine.module.Linear"
] | [((648, 661), 'megengine.module.init.fill_', 'fill_', (['x', '(5.0)'], {}), '(x, 5.0)\n', (653, 661), False, 'from megengine.module.init import calculate_fan_in_and_fan_out, fill_\n'), ((833, 870), 'megengine.module.Linear', 'Linear', ([], {'in_features': '(3)', 'out_features': '(8)'}), '(in_features=3, out_features=8)... |
from sfepy.base.testing import TestCommon, assert_, debug
class Test(TestCommon):
@staticmethod
def from_conf(conf, options):
return Test(conf=conf, options=options)
def test_tensors(self):
import numpy as nm
import sfepy.mechanics.tensors as tn
ok = True
a_full ... | [
"sfepy.mechanics.tensors.get_volumetric_tensor",
"sfepy.mechanics.tensors.get_deviator",
"sfepy.mechanics.tensors.get_trace",
"sfepy.mechanics.tensors.get_von_mises_stress"
] | [((433, 470), 'numpy.array', 'nm.array', (['([6.0] * 5)'], {'dtype': 'nm.float64'}), '([6.0] * 5, dtype=nm.float64)\n', (441, 470), True, 'import numpy as nm\n'), ((792, 831), 'sfepy.mechanics.tensors.get_trace', 'tn.get_trace', (['a_full'], {'sym_storage': '(False)'}), '(a_full, sym_storage=False)\n', (804, 831), True... |
# -*- 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.module.AvgPool2d",
"megengine.tensor"
] | [((725, 795), 'megengine.module.AvgPool2d', 'AvgPool2d', (['kernel_size'], {'stride': 'stride', 'padding': 'padding', 'mode': '"""average"""'}), "(kernel_size, stride=stride, padding=padding, mode='average')\n", (734, 795), False, 'from megengine.module import AvgPool2d, MaxPool2d\n'), ((1115, 1184), 'numpy.pad', 'np.p... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.data.transform.RandomResize",
"megengine.jit.trace",
"megengine.data.transform.RandomHorizontalFlip",
"megengine.distributed.init_process_group",
"megengine.load",
"megengine.data.dataset.Cityscapes",
"megengine.get_logger",
"megengine.data.transform.Normalize",
"megengine.data.transform.... | [((872, 896), 'megengine.get_logger', 'mge.get_logger', (['__name__'], {}), '(__name__)\n', (886, 896), True, 'import megengine as mge\n'), ((924, 949), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (947, 949), False, 'import argparse\n'), ((1986, 2022), 'official.vision.segmentation.utils.imp... |
import os
from typing import List
from sqlmodel.sql.expression import select
from utilities.filepath import get_home_dir
from sqlmodel import create_engine, SQLModel, Session
# these are imported so that the initialization of the database can be done
from schemas.common.event import Event
from schemas.common.extensio... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.sql.expression.select"
] | [((793, 834), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['self.engine'], {}), '(self.engine)\n', (821, 834), False, 'from sqlmodel import create_engine, SQLModel, Session\n'), ((897, 917), 'sqlmodel.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (904, 917), False, 'from s... |
"""v1-tenant_token
Revision ID: <KEY>
Revises: <KEY>
Create Date: 2022-05-18 14:55:32.794587
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = "<KEY>"
down_revision = "<KEY>"
branch_labels = None
depends_on = None
def upgrade():
op.add_column... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((596, 636), 'alembic.op.drop_column', 'op.drop_column', (['"""tenant"""', '"""wallet_token"""'], {}), "('tenant', 'wallet_token')\n", (610, 636), False, 'from alembic import op\n'), ((452, 474), 'alembic.op.f', 'op.f', (['"""ix_tenant_name"""'], {}), "('ix_tenant_name')\n", (456, 474), False, 'from alembic import op\... |
from sqlmodel import create_engine
from config import settings
engine = create_engine(settings.database_url)
| [
"sqlmodel.create_engine"
] | [((73, 109), 'sqlmodel.create_engine', 'create_engine', (['settings.database_url'], {}), '(settings.database_url)\n', (86, 109), False, 'from sqlmodel import create_engine\n')] |
"""
Basic uniform mesh refinement functions.
"""
import numpy as nm
from sfepy.discrete.fem import Mesh
def refine_2_3(mesh_in):
"""
Refines mesh out of triangles by cutting cutting each edge in half
and making 4 new finer triangles out of one coarser one.
"""
cmesh = mesh_in.cmesh
# Unique e... | [
"sfepy.discrete.fem.Mesh.from_data",
"sfepy.discrete.fem.FEDomain"
] | [((979, 1072), 'sfepy.discrete.fem.Mesh.from_data', 'Mesh.from_data', (["(mesh_in.name + '_r')", 'coors', 'None', '[new_conn]', '[new_mat_id]', 'mesh_in.descs'], {}), "(mesh_in.name + '_r', coors, None, [new_conn], [new_mat_id],\n mesh_in.descs)\n", (993, 1072), False, 'from sfepy.discrete.fem import Mesh\n'), ((217... |
# This example implements homogenization of piezoeletric porous media.
# The mathematical model and numerical results are described in:
#
# <NAME>., <NAME>.
# Homogenization of the fluid-saturated piezoelectric porous media.
# International Journal of Solids and Structures
# Volume 147, 15 August 2018, Pages 110-125
#... | [
"sfepy.mechanics.matcoefs.stiffness_from_youngpoisson",
"sfepy.homogenization.utils.define_box_regions",
"sfepy.base.base.Struct",
"sfepy.homogenization.utils.coor_to_sym",
"sfepy.discrete.fem.mesh.Mesh.from_file"
] | [((4603, 4632), 'sfepy.discrete.fem.mesh.Mesh.from_file', 'Mesh.from_file', (['filename_mesh'], {}), '(filename_mesh)\n', (4617, 4632), False, 'from sfepy.discrete.fem.mesh import Mesh\n'), ((4834, 4891), 'sfepy.homogenization.utils.define_box_regions', 'define_box_regions', (['mesh.dim', 'bbox[0]', 'bbox[1]'], {'eps':... |
from unittest.mock import patch
from sqlmodel import create_engine
from ....conftest import get_testing_print_function
expected_calls = [
[
"Created hero:",
{
"age": None,
"id": 1,
"secret_name": "<NAME>",
"team_id": 1,
"name": "Deadpond... | [
"sqlmodel.create_engine"
] | [((1912, 1941), 'sqlmodel.create_engine', 'create_engine', (['mod.sqlite_url'], {}), '(mod.sqlite_url)\n', (1925, 1941), False, 'from sqlmodel import create_engine\n'), ((2018, 2056), 'unittest.mock.patch', 'patch', (['"""builtins.print"""'], {'new': 'new_print'}), "('builtins.print', new=new_print)\n", (2023, 2056), F... |
from typing import Optional
from sqlmodel import Field, SQLModel
__all__ = ['User']
class User(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
username: str = Field(index=False, nullable=False)
password: str = Field(index=False, nullable=False)
| [
"sqlmodel.Field"
] | [((146, 183), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (151, 183), False, 'from sqlmodel import Field, SQLModel\n'), ((204, 238), 'sqlmodel.Field', 'Field', ([], {'index': '(False)', 'nullable': '(False)'}), '(index=False, nullable=False)\n', (... |
from __future__ import absolute_import
import os.path as op
import numpy as nm
import sfepy
from sfepy.discrete import FieldVariable
from sfepy.discrete.fem import Mesh, FEDomain, Field
from sfepy.base.base import assert_
from sfepy.base.testing import TestCommon
class Test(TestCommon):
@staticmethod
def fr... | [
"sfepy.mesh.mesh_generators.gen_block_mesh",
"sfepy.discrete.projections.make_l2_projection_data",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.iga.domain_generators.gen_patch_block_domain",
"sfepy.discrete.fem.Field.from_args",
"sfepy.discrete.fem.FEDomain",
"sfepy.base.base.assert_",
"sfepy.... | [((359, 434), 'sfepy.discrete.fem.Mesh.from_file', 'Mesh.from_file', (['"""meshes/2d/square_unit_tri.mesh"""'], {'prefix_dir': 'sfepy.data_dir'}), "('meshes/2d/square_unit_tri.mesh', prefix_dir=sfepy.data_dir)\n", (373, 434), False, 'from sfepy.discrete.fem import Mesh, FEDomain, Field\n'), ((482, 506), 'sfepy.discrete... |
r"""
Laplace equation with Dirichlet boundary conditions given by a sine function
and constants.
Find :math:`t` such that:
.. math::
\int_{\Omega} c \nabla s \cdot \nabla t
= 0
\;, \quad \forall s \;.
The :class:`sfepy.discrete.fem.meshio.UserMeshIO` class is used to refine the
original two-element mesh ... | [
"sfepy.base.base.output",
"sfepy.discrete.fem.meshio.UserMeshIO",
"sfepy.homogenization.utils.define_box_regions",
"sfepy.discrete.fem.meshio.MeshIO.any_from_filename",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.discrete.fem.FEDomain"
] | [((3111, 3132), 'sfepy.discrete.fem.meshio.UserMeshIO', 'UserMeshIO', (['mesh_hook'], {}), '(mesh_hook)\n', (3121, 3132), False, 'from sfepy.discrete.fem.meshio import UserMeshIO, MeshIO\n'), ((3176, 3211), 'sfepy.discrete.fem.meshio.MeshIO.any_from_filename', 'MeshIO.any_from_filename', (['base_mesh'], {}), '(base_mes... |
#!/usr/bin/env python3
import argparse
import math
import megengine.functional as F
import megengine.module as M
import numpy as np
from megengine import jit, tensor
class ConvNet(M.Module):
def __init__(self):
super().__init__()
self.conv1 = M.Conv2d(in_channels=3, out_channels=1, kernel_size=... | [
"megengine.module.Conv2d",
"megengine.jit.trace"
] | [((457, 583), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""dump mge model for add_demo"""', 'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), "(description='dump mge model for add_demo',\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n", (480, 583), False, 'i... |
# Copyright (c) 2020 <NAME>
# This code is licensed under MIT license
# (https://github.com/kwotsin/mimicry/blob/master/LICENSE)
# ------------------------------------------------------------------------------
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megv... | [
"megengine.functional.maximum",
"megengine.functional.sigmoid",
"megengine.core.tensor_factory.zeros",
"megengine.functional.log",
"megengine.functional.abs"
] | [((1132, 1154), 'megengine.functional.sigmoid', 'F.sigmoid', (['output_fake'], {}), '(output_fake)\n', (1141, 1154), True, 'import megengine.functional as F\n'), ((2374, 2406), 'megengine.core.tensor_factory.zeros', 'zeros', (['(output_fake.shape[0], 1)'], {}), '((output_fake.shape[0], 1))\n', (2379, 2406), False, 'fro... |
import os
from fastapi import *
from psycopg2.errors import UndefinedTable
from sqlmodel import Session, select, text
from sqlalchemy.exc import ProgrammingError
from .models.timelog import TimeLog
from .models.calendar import Calendar
from .utils import (
engine,
create_db,
tags_metadata,
execute_sampl... | [
"sqlmodel.Session",
"sqlmodel.select",
"sqlmodel.text"
] | [((1035, 1050), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1042, 1050), False, 'from sqlmodel import Session, select, text\n'), ((1620, 1635), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1627, 1635), False, 'from sqlmodel import Session, select, text\n'), ((1074, 1099), 'os.gete... |
"""(Basic) Message Tables/Models.
Models of the Traction tables for Messages (layer over AcaPy basic messaging).
"""
import uuid
from datetime import datetime
from typing import List, Optional
from sqlalchemy.orm import selectinload
from sqlmodel import Field, Relationship
from sqlalchemy import (
Column,
fu... | [
"sqlmodel.Field",
"sqlmodel.Relationship"
] | [((1808, 1850), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""tenant.id"""', 'index': '(True)'}), "(foreign_key='tenant.id', index=True)\n", (1813, 1850), False, 'from sqlmodel import Field, Relationship\n'), ((1879, 1930), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""contact.contact_id"""', 'index': '(Tru... |
# 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.qint32",
"megengine._internal.dtype.qint8",
"megengine._internal.dtype.get_scale"
] | [((3763, 3794), 'functools.partial', 'partial', (['to_quantized', 'ConvBn2d'], {}), '(to_quantized, ConvBn2d)\n', (3770, 3794), False, 'from functools import partial\n'), ((3841, 3876), 'functools.partial', 'partial', (['to_quantized', 'ConvBnRelu2d'], {}), '(to_quantized, ConvBnRelu2d)\n', (3848, 3876), False, 'from f... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.