code stringlengths 110 64.5k | apis list | extract_api stringlengths 123 69.9k |
|---|---|---|
# -*- 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.distributed.get_rank",
"megengine.quantization.enable_fake_quant",
"megengine.tensor",
"megengine.functional.nn.cross_entropy",
"megengine.quantization.enable_observer",
"megengine.quantization.quantize_qat",
"megengine.jit.SublinearMemoryConfig",
"megengine.optimiz... | [((908, 937), 'megengine.logger.get_logger', 'megengine.logger.get_logger', ([], {}), '()\n', (935, 937), False, 'import megengine\n'), ((1301, 1360), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""shufflenet benchmark"""'}), "(description='shufflenet benchmark')\n", (1324, 1360), False,... |
#!/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.models.repvgg import RepVGGBlock
@pytest.mark.parametrize("w_in", [32, 64])
@pytest.mark.parametrize("w_out", [64])
@pytest.mark.paramet... | [
"megengine.random.uniform"
] | [((218, 259), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_in"""', '[32, 64]'], {}), "('w_in', [32, 64])\n", (241, 259), False, 'import pytest\n'), ((261, 299), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""w_out"""', '[64]'], {}), "('w_out', [64])\n", (284, 299), False, 'import pytest\n'... |
from fastapi import Depends
from sqlmodel import select
from joj.horse import models, schemas
from joj.horse.schemas import StandardListResponse
from joj.horse.schemas.auth import Authentication
from joj.horse.utils.parser import parse_ordering_query, parse_pagination_query
from joj.horse.utils.router import MyRouter
... | [
"sqlmodel.select"
] | [((330, 340), 'joj.horse.utils.router.MyRouter', 'MyRouter', ([], {}), '()\n', (338, 340), False, 'from joj.horse.utils.router import MyRouter\n'), ((589, 620), 'fastapi.Depends', 'Depends', (['parse_pagination_query'], {}), '(parse_pagination_query)\n', (596, 620), False, 'from fastapi import Depends\n'), ((649, 658),... |
# -*- 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.random.normal",
"megengine.functional.adaptive_max_pool2d",
"megengine.functional.avg_pool2d",
"megengine.module.Conv2d",
"megengine.functional.repeat",
"megengine.functional.max_pool2d",
"megengine.functional.squeeze",
"megengine.module.BatchNorm2d",
"megengine.functional.leaky_relu",
... | [((10595, 10609), 'numpy.mean', 'np.mean', (['times'], {}), '(times)\n', (10602, 10609), True, 'import numpy as np\n'), ((629, 655), 'megengine.module.Conv2d', 'MM.Conv2d', (['(32)', '(32)', '(3)', '(1)', '(0)'], {}), '(32, 32, 3, 1, 0)\n', (638, 655), True, 'import megengine.module as MM\n'), ((720, 757), 'megengine.m... |
import datetime
from typing import Optional
from sqlmodel import BigInteger, Column, DateTime, Field, ForeignKey, SQLModel
class HelpSessionBase(SQLModel):
"""A base model for storing information about users."""
claimant_id: int
channel_id: int
opened_at: datetime.datetime
closed_at: Optional[da... | [
"sqlmodel.Field",
"sqlmodel.DateTime",
"sqlmodel.Column",
"sqlmodel.ForeignKey"
] | [((526, 549), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (531, 549), False, 'from sqlmodel import BigInteger, Column, DateTime, Field, ForeignKey, SQLModel\n'), ((788, 848), 'sqlmodel.Column', 'Column', (['"""channel_id"""', 'BigInteger'], {'index': '(True)', 'nullable': '(False... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.test.assertTensorClose",
"megengine.save",
"megengine.tensor",
"megengine.functional.relu",
"megengine.functional.flatten",
"megengine.functional.debug_param.set_conv_execution_strategy",
"megengine.module.Conv2d",
"megengine.module.AvgPool2d",
"megengine.functional.cross_entropy_with_sof... | [((1407, 1430), 'megengine.is_cuda_available', 'mge.is_cuda_available', ([], {}), '()\n', (1428, 1430), True, 'import megengine as mge\n'), ((2486, 2527), 'megengine.functional.cross_entropy_with_softmax', 'F.cross_entropy_with_softmax', (['pred', 'label'], {}), '(pred, label)\n', (2514, 2527), True, 'import megengine.... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.module.ReLU",
"megengine.tensor",
"megengine.functional.top_k",
"megengine.module.init.zeros_",
"megengine.module.init.msra_normal_",
"megengine.module.init.calculate_fan_in_and_fan_out",
"megengine.module.ConvTranspose2d",
"megengine.module.Sequential",
"megengine.module.Conv2d",
"mege... | [((7936, 8043), 'megengine.hub.pretrained', 'hub.pretrained', (['"""https://data.megengine.org.cn/models/weights/mspn_4stage_256x192_0_255_75_2.pkl"""'], {}), "(\n 'https://data.megengine.org.cn/models/weights/mspn_4stage_256x192_0_255_75_2.pkl'\n )\n", (7950, 8043), True, 'import megengine.hub as hub\n'), ((2520... |
import os.path as op
import numpy as nm
from sfepy.base.conf import transform_variables
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)
def gen_datas(meshes):
... | [
"sfepy.discrete.common.mappings.get_physical_qps",
"sfepy.discrete.fem.Mesh",
"sfepy.terms.Term.new",
"sfepy.base.conf.transform_variables",
"sfepy.discrete.Integral",
"sfepy.discrete.fem.Field.from_args",
"sfepy.discrete.fem.FEDomain",
"sfepy.linalg.make_axis_rotation_matrix"
] | [((1266, 1284), 'sfepy.discrete.fem.FEDomain', 'FEDomain', (['"""d1"""', 'm1'], {}), "('d1', m1)\n", (1274, 1284), False, 'from sfepy.discrete.fem import Mesh, FEDomain, Field\n'), ((1374, 1449), 'sfepy.discrete.fem.Field.from_args', 'Field.from_args', (['"""f"""', 'nm.float64', 'f[0]', 'd1.regions[f[1]]'], {'approx_or... |
# -*- 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.tensor",
"megengine.module.ReLU",
"megengine._internal.cgtools.get_inputs",
"megengine.module.BatchNorm2d",
"megengine._internal.load_comp_graph_from_file",
"megengine.module.Conv2d",
"megengine._internal.opr.assert_equal",
"megengine.jit.trace"... | [((770, 788), 'tempfile.mkstemp', 'tempfile.mkstemp', ([], {}), '()\n', (786, 788), False, 'import tempfile\n'), ((927, 963), 'megengine._internal.load_comp_graph_from_file', 'mgb.load_comp_graph_from_file', (['fpath'], {}), '(fpath)\n', (956, 963), True, 'import megengine._internal as mgb\n'), ((977, 1029), 'megengine... |
# 30.05.2007, c
# last revision: 25.02.2008
from __future__ import absolute_import
from sfepy import data_dir
import six
filename_mesh = data_dir + '/meshes/2d/square_unit_tri.mesh'
material_1 = {
'name' : 'coef',
'values' : {
'val' : 1.0,
},
}
material_2 = {
'name' : 'm',
'values' : {
... | [
"sfepy.applications.solve_pde",
"sfepy.linalg.rotation_matrix2d",
"sfepy.discrete.Material.from_conf",
"sfepy.discrete.evaluate.BasicEvaluator"
] | [((2386, 2421), 'sfepy.applications.solve_pde', 'solve_pde', (['conf'], {'save_results': '(False)'}), '(conf, save_results=False)\n', (2395, 2421), False, 'from sfepy.applications import solve_pde\n'), ((2813, 2831), 'six.iteritems', 'six.iteritems', (['sol'], {}), '(sol)\n', (2826, 2831), False, 'import six\n'), ((404... |
"""add school abbreviations and acronyms
Revision ID: 41f361ac6a74
Revises: c<PASSWORD>
Create Date: 2022-06-07 03:48:15.445488+00:00
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = "41f361ac6a74"
down_r... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((1100, 1141), 'alembic.op.drop_column', 'op.drop_column', (['"""schools"""', '"""alternatives"""'], {}), "('schools', 'alternatives')\n", (1114, 1141), False, 'from alembic import op\n'), ((1146, 1188), 'alembic.op.drop_column', 'op.drop_column', (['"""schools"""', '"""abbreviations"""'], {}), "('schools', 'abbreviat... |
from typing import Optional
from pydantic import EmailStr
from sqlmodel import Field, SQLModel
# define your database tables (models) here
class User(SQLModel, table=True):
id: Optional[int] = Field(default=None, nullable=False, primary_key=True)
name: str = Field(nullable=False)
email: EmailStr = Field(... | [
"sqlmodel.Field"
] | [((200, 253), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'nullable': '(False)', 'primary_key': '(True)'}), '(default=None, nullable=False, primary_key=True)\n', (205, 253), False, 'from sqlmodel import Field, SQLModel\n'), ((270, 291), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)... |
# -*- 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.distributed.is_distributed",
"megengine.distributed.get_rank",
"megengine.distributed.get_world_size",
"megengine.distributed.all_reduce_sum",
"megengine.distributed.init_process_group"
] | [((2327, 2352), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2350, 2352), False, 'import argparse\n'), ((3419, 3460), 'devkit.core.init_dist', 'init_dist', ([], {'backend': '"""nccl"""', 'port': 'args.port'}), "(backend='nccl', port=args.port)\n", (3428, 3460), False, 'from devkit.core impor... |
from typing import Optional
from datetime import datetime
from sqlalchemy import DateTime, String
from sqlalchemy.sql.schema import Column
from sqlmodel import Field, SQLModel
class Test(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
class DataStorage(SQLModel, ta... | [
"sqlmodel.Field"
] | [((237, 274), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (242, 274), False, 'from sqlmodel import Field, SQLModel\n'), ((351, 379), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""test.id"""'}), "(foreign_key='test.id')\n", (356, 379), False,... |
import os
from sqlmodel import create_engine, Session, select, update
from functools import lru_cache
from typing import Union
from sqlalchemy.exc import NoResultFound
engine = create_engine(os.environ.get('DB_CONN'))
# Grim hack to get the imports working with crawler and main.
# TODO: Split poke models and other c... | [
"sqlmodel.Session",
"sqlmodel.select",
"sqlmodel.update"
] | [((633, 654), 'functools.lru_cache', 'lru_cache', ([], {'maxsize': '(16)'}), '(maxsize=16)\n', (642, 654), False, 'from functools import lru_cache\n'), ((193, 218), 'os.environ.get', 'os.environ.get', (['"""DB_CONN"""'], {}), "('DB_CONN')\n", (207, 218), False, 'import os\n'), ((1039, 1054), 'sqlmodel.Session', 'Sessio... |
"""
Acoustic band gaps in a strongly heterogeneous elastic body, detected using
homogenization techniques.
A reference periodic cell contains two domains: the stiff matrix :math:`Y_m`
and the soft (but heavy) inclusion :math:`Y_c`.
"""
from sfepy import data_dir
from sfepy.base.base import Struct
from sfepy.base.iouti... | [
"sfepy.base.base.Struct",
"sfepy.homogenization.coefficients.Coefficients",
"sfepy.base.ioutils.InDir"
] | [((524, 539), 'sfepy.base.ioutils.InDir', 'InDir', (['__file__'], {}), '(__file__)\n', (529, 539), False, 'from sfepy.base.ioutils import InDir\n'), ((678, 703), 'band_gaps_conf.get_pars', 'get_pars', (['(2)', '(5.898)', '(2.681)'], {}), '(2, 5.898, 2.681)\n', (686, 703), False, 'from band_gaps_conf import BandGapsConf... |
import pytest
from typing import Optional
from sqlmodel import Field, Session, SQLModel, create_engine
from sqlalchemy.exc import IntegrityError
def test_should_allow_duplicate_row_if_unique_constraint_is_not_passed(clear_sqlmodel):
class Hero(SQLModel, table=True):
id: Optional[int] = Field(def... | [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field"
] | [((563, 589), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite://"""'], {}), "('sqlite://')\n", (576, 589), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((597, 633), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (625, 633), F... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import megengine as mge
import megengine.module as M
import pytest
from basecls.models.regnet import RegBottleneckBlock
from basecls.models.resnet import (
AnyStage,
ResBasicBlock,
ResBottleneckBlock,
ResDeepStem,
Res... | [
"megengine.random.normal"
] | [((347, 440), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""Block"""', '[RegBottleneckBlock, ResBasicBlock, ResBottleneckBlock]'], {}), "('Block', [RegBottleneckBlock, ResBasicBlock,\n ResBottleneckBlock])\n", (370, 440), False, 'import pytest\n'), ((438, 475), 'pytest.mark.parametrize', 'pytest.mark.p... |
from datetime import datetime
import logging
from typing import List, Optional
from pydantic import BaseConfig
from sqlmodel import Field, SQLModel, Session
import shortuuid
import random
from faker import Faker
# Line items that would be on a receipt
# Each line item has an id, sku, price, quantity, and transaction_i... | [
"sqlmodel.Session",
"sqlmodel.Field"
] | [((374, 411), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (379, 411), False, 'from sqlmodel import Field, SQLModel, Session\n'), ((427, 459), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""product.sku"""'}), "(foreign_key='product.sku')\n", (... |
"""Patron CRUD controller."""
from typing import Any, Dict
import sqlmodel
from sqlmodel.ext.asyncio import session as aio_session
from app.core import security
from app.crud import base
from app.models import patron
class PatronCRUD(base.BaseCRUD[patron.Patron, patron.PatronCreate,
... | [
"sqlmodel.select"
] | [((1179, 1230), 'app.core.security.get_password_hash', 'security.get_password_hash', (["update_data['password']"], {}), "(update_data['password'])\n", (1205, 1230), False, 'from app.core import security\n'), ((2634, 2690), 'app.core.security.verify_password', 'security.verify_password', (['password', 'user.hashed_passw... |
"""init_db
Revision ID: 23799b5136c5
Revises:
Create Date: 2021-12-11 00:49:58.116933
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = '23799b5136c5'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### commands... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((2498, 2519), 'alembic.op.drop_table', 'op.drop_table', (['"""task"""'], {}), "('task')\n", (2511, 2519), False, 'from alembic import op\n'), ((2906, 2927), 'alembic.op.drop_table', 'op.drop_table', (['"""user"""'], {}), "('user')\n", (2919, 2927), False, 'from alembic import op\n'), ((808, 837), 'sqlalchemy.PrimaryK... |
import uuid
from datetime import datetime
from sqlmodel import Field
from api.db.models.base import BaseModel, BaseTable
class IssueCredentialBase(BaseModel):
tenant_id: uuid.UUID = Field(nullable=False)
wallet_id: uuid.UUID = Field(nullable=False)
connection_id: uuid.UUID = Field(nullable=False)
cr... | [
"sqlmodel.Field"
] | [((190, 211), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (195, 211), False, 'from sqlmodel import Field\n'), ((239, 260), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (244, 260), False, 'from sqlmodel import Field\n'), ((292, 313), 'sqlmodel.Field'... |
# -*- 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.module.external.ExternOprSubgraph"
] | [((666, 774), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""load a .pb model and convert to corresponding load-and-run model"""'}), "(description=\n 'load a .pb model and convert to corresponding load-and-run model')\n", (689, 774), False, 'import argparse\n'), ((1185, 1197), 'yaml.l... |
from sqlmodel import Field
from taskana_api.entities.tasks import TaskBase
class Task(TaskBase, table=True):
id: int = Field(primary_key=True)
| [
"sqlmodel.Field"
] | [((126, 149), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (131, 149), False, 'from sqlmodel import Field\n')] |
from datetime import date, datetime
from typing import Any, Dict, Optional
from uuid import UUID, uuid4
from pydantic.class_validators import root_validator
from sqlmodel import Column, Enum, Field, SQLModel
from sqlmodel.sql.sqltypes import GUID
from ...utils.date import now_datetime
from ..constants import Operatio... | [
"sqlmodel.sql.sqltypes.GUID",
"sqlmodel.Enum",
"sqlmodel.Field"
] | [((399, 438), 'sqlmodel.Field', 'Field', ([], {'description': '"""Value of operation"""'}), "(description='Value of operation')\n", (404, 438), False, 'from sqlmodel import Column, Enum, Field, SQLModel\n'), ((601, 660), 'sqlmodel.Field', 'Field', ([], {'description': '"""Description of operation"""', 'min_length': '(1... |
# 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.functional.conv2d",
"megengine.functional.reshape",
"megengine.core.tensor.dtype.convert_to_qint4",
"megengine.functional.transpose",
"megengine.core.tensor.dtype.qint32",
"megengine.functional.clip",
"megengine.Tensor",
"megengine.core.tensor.dtype.qint4",
"megengine.device.get_device_co... | [((966, 1044), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""kind"""', "['abs', 'sin', 'sub', 'mul', 'fuse_add_tanh']"], {}), "('kind', ['abs', 'sin', 'sub', 'mul', 'fuse_add_tanh'])\n", (989, 1044), False, 'import pytest\n'), ((5797, 5887), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""does... |
#!/usr/bin/env python
r"""
Parallel assembling and solving of a Biot problem (deformable porous medium),
using commands for interactive use.
Find :math:`\ul{u}`, :math:`p` such that:
.. math::
\int_{\Omega} D_{ijkl}\ e_{ij}(\ul{v}) e_{kl}(\ul{u})
- \int_{\Omega} p\ \alpha_{ij} e_{ij}(\ul{v})
= 0
\;, ... | [
"sfepy.parallel.parallel.partition_mesh",
"sfepy.discrete.Equation",
"sfepy.parallel.evaluate.PETScParallelEvaluator",
"sfepy.discrete.conditions.EssentialBC",
"sfepy.base.base.Struct",
"sfepy.discrete.fem.Mesh.from_file",
"sfepy.parallel.parallel.create_gather_to_zero",
"sfepy.mesh.mesh_generators.ge... | [((4531, 4578), 'sfepy.discrete.fem.Mesh.from_region', 'Mesh.from_region', (['omega_gi', 'mesh'], {'localize': '(True)'}), '(omega_gi, mesh, localize=True)\n', (4547, 4578), False, 'from sfepy.discrete.fem import Mesh, FEDomain, Field\n'), ((4594, 4622), 'sfepy.discrete.fem.FEDomain', 'FEDomain', (['"""domain_i"""', 'm... |
"""
Reference-physical domain mappings.
"""
import numpy as nm
from sfepy.base.base import Struct
class PhysicalQPs(Struct):
"""
Physical quadrature points in a region.
"""
def __init__(self, igs, n_total=0, is_uniform=True):
Struct.__init__(self, igs=igs, n_total=n_total, indx={}, rindx={},
... | [
"sfepy.discrete.iga.mappings.SurfaceMapping",
"sfepy.discrete.iga.mappings.VolumeMapping",
"sfepy.discrete.iga.mappings.IGMapping",
"sfepy.base.base.Struct.__init__"
] | [((253, 383), 'sfepy.base.base.Struct.__init__', 'Struct.__init__', (['self'], {'igs': 'igs', 'n_total': 'n_total', 'indx': '{}', 'rindx': '{}', 'n_per_group': '{}', 'shape': '{}', 'values': '{}', 'is_uniform': 'is_uniform'}), '(self, igs=igs, n_total=n_total, indx={}, rindx={},\n n_per_group={}, shape={}, values={}... |
from decouple import config
from sqlmodel import Session, SQLModel, create_engine
DATABASE_URL = config("DATABASE_URL")
DEBUG = config("DEBUG", default=False, cast=bool)
engine = create_engine(DATABASE_URL, echo=DEBUG)
def get_session():
with Session(engine) as session:
yield session
def create_db_an... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.create_engine"
] | [((98, 120), 'decouple.config', 'config', (['"""DATABASE_URL"""'], {}), "('DATABASE_URL')\n", (104, 120), False, 'from decouple import config\n'), ((129, 170), 'decouple.config', 'config', (['"""DEBUG"""'], {'default': '(False)', 'cast': 'bool'}), "('DEBUG', default=False, cast=bool)\n", (135, 170), False, 'from decoup... |
"""init database
Revision ID: 60e58d3a26fa
Revises:
Create Date: 2021-11-24 18:06:53.935899
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = '60e58d3a26fa'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### co... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((3717, 3753), 'alembic.op.drop_table', 'op.drop_table', (['"""customerproductlink"""'], {}), "('customerproductlink')\n", (3730, 3753), False, 'from alembic import op\n'), ((4183, 4208), 'alembic.op.drop_table', 'op.drop_table', (['"""customer"""'], {}), "('customer')\n", (4196, 4208), False, 'from alembic import op\... |
import numpy as np
import megengine.functional as F
import megengine.module as M
from config import config
from .anchors_generator import AnchorGenerator
from .find_top_rpn_proposals import find_top_rpn_proposals
from .fpn_anchor_target import fpn_anchor_target, fpn_rpn_reshape
from det_opr.loss_opr import softmax_loss... | [
"megengine.module.init.fill_",
"megengine.module.init.normal_",
"megengine.module.Conv2d"
] | [((640, 702), 'megengine.module.Conv2d', 'M.Conv2d', (['(256)', 'rpn_channel'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(256, rpn_channel, kernel_size=3, stride=1, padding=1)\n', (648, 702), True, 'import megengine.module as M\n'), ((732, 807), 'megengine.module.Conv2d', 'M.Conv2d', (['rpn_channel'... |
r"""
Thermo-elasticity with a given temperature distribution.
Uses `dw_biot` term with an isotropic coefficient for thermo-elastic coupling.
For given body temperature :math:`T` and background temperature
:math:`T_0` find :math:`\ul{u}` such that:
.. math::
\int_{\Omega} D_{ijkl}\ e_{ij}(\ul{v}) e_{kl}(\ul{u})
... | [
"sfepy.base.base.Struct",
"sfepy.mechanics.matcoefs.stiffness_from_lame"
] | [((3335, 3393), 'numpy.array', 'np.array', (['[[1], [1], [1], [0], [0], [0]]'], {'dtype': 'np.float64'}), '([[1], [1], [1], [0], [0], [0]], dtype=np.float64)\n', (3343, 3393), True, 'import numpy as np\n'), ((1516, 1579), 'sfepy.base.base.Struct', 'Struct', ([], {'name': '"""output_data"""', 'mode': '"""cell"""', 'data... |
from typing import Optional
from sqlalchemy import UniqueConstraint
from sqlmodel import Field, Relationship, SQLModel
from db.base import BaseDBModel
from model.item import Item
from model.warehouse import Warehouse
class InventoryEditableFields(SQLModel):
item_id: int = Field(foreign_key="item.id")
wareho... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((281, 309), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""item.id"""'}), "(foreign_key='item.id')\n", (286, 309), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((334, 367), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""warehouse.id"""'}), "(foreign_key='warehouse.id')\n", (339, 367), Fal... |
"""
Models for columns.
"""
from typing import TYPE_CHECKING, Optional, TypedDict
from sqlalchemy.sql.schema import Column as SqlaColumn
from sqlalchemy.types import Enum
from sqlmodel import Field, Relationship, SQLModel
from datajunction.typing import ColumnType
if TYPE_CHECKING:
from datajunction.models.node... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((694, 731), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (699, 731), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((850, 892), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""node.id"""'}), "(default=None... |
from typing import Optional
from sqlmodel import Field, SQLModel, Relationship, Column
from sqlalchemy_utils.types import TSVectorType
from .db import stand_by_models, stand_by_db
stand_by_models()
class Hero(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
cont... | [
"sqlmodel.Field"
] | [((260, 297), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (265, 297), False, 'from sqlmodel import Field, SQLModel, Relationship, Column\n'), ((670, 707), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=Non... |
#!/usr/bin/env python
r"""
Parallel assembling and solving of a Poisson's equation, using commands for
interactive use.
Find :math:`u` such that:
.. math::
\int_{\Omega} \nabla v \cdot \nabla u
= \int_{\Omega} v f
\;, \quad \forall s \;.
Important Notes
---------------
- This example requires petsc4py, ... | [
"sfepy.parallel.parallel.assemble_rhs_to_petsc",
"sfepy.mesh.mesh_generators.gen_block_mesh",
"sfepy.parallel.parallel.create_gather_scatter",
"sfepy.base.ioutils.ensure_path",
"sfepy.parallel.parallel.create_local_petsc_vector",
"sfepy.discrete.fem.Mesh.from_region",
"sfepy.discrete.fem.Mesh.from_file"... | [((2114, 2134), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (2129, 2134), False, 'import sys\n'), ((3216, 3263), 'sfepy.discrete.fem.Mesh.from_region', 'Mesh.from_region', (['omega_gi', 'mesh'], {'localize': '(True)'}), '(omega_gi, mesh, localize=True)\n', (3232, 3263), False, 'from sfepy.discre... |
# -*- 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 ARRANTIE... | [
"megengine.functional.zeros",
"megengine.functional.topk",
"megengine.random.uniform",
"megengine.functional.zeros_like"
] | [((1015, 1038), 'megengine.random.uniform', 'uniform', ([], {'size': 'num_class'}), '(size=num_class)\n', (1022, 1038), False, 'from megengine.random import uniform\n'), ((1060, 1106), 'megengine.functional.topk', 'F.topk', (['topk_tensor'], {'k': '(num_samples - num_class)'}), '(topk_tensor, k=num_samples - num_class)... |
"""
Computational domain for isogeometric analysis.
"""
import os.path as op
import numpy as nm
from sfepy.base.base import assert_, Struct
from sfepy.discrete.common.domain import Domain
import sfepy.discrete.iga as iga
import sfepy.discrete.iga.io as io
from sfepy.discrete.iga.extmods.igac import eval_in_tp_coors
... | [
"sfepy.discrete.fem.geometry_element.create_geometry_elements",
"sfepy.discrete.iga.io.read_iga_data",
"sfepy.discrete.iga.get_bezier_topology",
"sfepy.discrete.common.domain.Domain.__init__",
"sfepy.base.base.Struct",
"sfepy.discrete.iga.compute_bezier_extraction",
"sfepy.discrete.iga.extmods.igac.eval... | [((491, 526), 'numpy.asarray', 'nm.asarray', (['degrees'], {'dtype': 'nm.int32'}), '(degrees, dtype=nm.int32)\n', (501, 526), True, 'import numpy as nm\n'), ((696, 809), 'sfepy.base.base.Struct.__init__', 'Struct.__init__', (['self'], {'name': '"""nurbs"""', 'knots': 'knots', 'degrees': 'degrees', 'cps': 'cps', 'weight... |
#!/usr/bin/env python
# 12.01.2007, c
from __future__ import absolute_import
from argparse import ArgumentParser
import sfepy
from sfepy.base.base import output
from sfepy.base.conf import ProblemConf, get_standard_keywords
from sfepy.homogenization.band_gaps_app import AcousticBandGapsApp
from sfepy.base.plotutils im... | [
"sfepy.base.conf.get_standard_keywords",
"sfepy.homogenization.band_gaps_app.AcousticBandGapsApp",
"sfepy.base.base.output",
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.base.base.debug_on_error"
] | [((820, 836), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (834, 836), False, 'from argparse import ArgumentParser\n'), ((2449, 2472), 'sfepy.base.conf.get_standard_keywords', 'get_standard_keywords', ([], {}), '()\n', (2470, 2472), False, 'from sfepy.base.conf import ProblemConf, get_standard_keyword... |
r"""
Thermo-elasticity with a computed temperature demonstrating equation sequence
solver.
Uses `dw_biot` term with an isotropic coefficient for thermo-elastic coupling.
The equation sequence solver (``'ess'`` in ``solvers``) automatically solves
first the temperature distribution and then the elasticity problem with... | [
"sfepy.mechanics.matcoefs.stiffness_from_lame"
] | [((2177, 2235), 'numpy.array', 'np.array', (['[[1], [1], [1], [0], [0], [0]]'], {'dtype': 'np.float64'}), '([[1], [1], [1], [0], [0], [0]], dtype=np.float64)\n', (2185, 2235), True, 'import numpy as np\n'), ((2281, 2319), 'sfepy.mechanics.matcoefs.stiffness_from_lame', 'stiffness_from_lame', (['(3)'], {'lam': 'lam', 'm... |
from datetime import datetime, timedelta
import pendulum
import prefect
from prefect import Flow, task
from prefect.run_configs import DockerRun
from prefect.schedules import CronSchedule
from prefect.storage import GitHub
from scrapy.crawler import CrawlerProcess
from sqlmodel import SQLModel, create_engine
from imd... | [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.create_engine"
] | [((1089, 1178), 'prefect.storage.GitHub', 'GitHub', ([], {'repo': '"""PeregHer/imdb-rating-predictions"""', 'path': '"""imdb_rating/workflow/flow.py"""'}), "(repo='PeregHer/imdb-rating-predictions', path=\n 'imdb_rating/workflow/flow.py')\n", (1095, 1178), False, 'from prefect.storage import GitHub\n'), ((1188, 1227... |
import megengine as mge
import megengine.functional as F
import numpy as np
from megengine import Tensor
import pdb
def softmax_loss(pred, label, ignore_label=-1):
max_pred = pred.max(axis=1, keepdims=True).detach()
pred -= max_pred
log_prob = pred - F.log(F.exp(pred).sum(axis=1, keepdims=True))
mask =... | [
"megengine.functional.exp",
"megengine.functional.pow",
"megengine.functional.equal",
"megengine.functional.zeros",
"megengine.functional.log",
"megengine.functional.ones",
"megengine.functional.expand_dims",
"megengine.functional.abs"
] | [((1072, 1080), 'megengine.functional.abs', 'F.abs', (['x'], {}), '(x)\n', (1077, 1080), True, 'import megengine.functional as F\n'), ((3251, 3271), 'megengine.functional.abs', 'F.abs', (['(pred - target)'], {}), '(pred - target)\n', (3256, 3271), True, 'import megengine.functional as F\n'), ((4722, 4748), 'megengine.f... |
#!/usr/bin/env python
def configuration(parent_package='', top_path=None):
import os.path as op
from numpy.distutils.misc_util import Configuration
from sfepy import Config
site_config = Config()
system = site_config.system()
os_flag = {'posix' : 0, 'windows' : 1}[system]
auto_dir = op.d... | [
"sfepy.Config"
] | [((206, 214), 'sfepy.Config', 'Config', ([], {}), '()\n', (212, 214), False, 'from sfepy import Config\n'), ((316, 336), 'os.path.dirname', 'op.dirname', (['__file__'], {}), '(__file__)\n', (326, 336), True, 'import os.path as op\n'), ((389, 439), 'numpy.distutils.misc_util.Configuration', 'Configuration', (['auto_name... |
import datetime
import typing
from sqlmodel import SQLModel, Field, Relationship
import typing as tp
import ipaddress
from sqlalchemy import UniqueConstraint
if tp.TYPE_CHECKING:
from .user import User
class LoginToken(SQLModel, table=True):
__tablename__:str = "login_tokens" # type: ignore
__table_args... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((368, 391), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (373, 391), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((496, 524), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""user.id"""'}), "(foreign_key='user.id')\n", (501, 524), False, 'from sqlmodel imp... |
"""add power
Revision ID: 135aec058ce1
Revises: 4400883a1249
Create Date: 2021-12-28 11:38:37.439383
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
# revision identifiers, used by Alembic.
revision = "135aec058ce1"
down_revision = "4400883a1249"
branch_labels = None
depends_on = None
def upgrad... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((613, 645), 'alembic.op.drop_column', 'op.drop_column', (['"""preps"""', '"""power"""'], {}), "('preps', 'power')\n", (627, 645), False, 'from alembic import op\n'), ((437, 471), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (469, 471), False, 'import sqlmodel\n')] |
from datetime import datetime, date
from decimal import Decimal
from typing import Optional, List
from fastapi import APIRouter, Depends
from sqlmodel import Field, SQLModel
from ...db import get_session
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
router = APIRouter()
class Histo... | [
"sqlmodel.Field"
] | [((295, 306), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (304, 306), False, 'from fastapi import APIRouter, Depends\n'), ((377, 414), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (382, 414), False, 'from sqlmodel import Field, SQLModel\n')... |
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
import cv2
import megengine.functional as F
import numpy as np
__all__ = [
"preprocess",
"postprocess",
]
def preprocess(image, input_size, mean, std, swap=(2, 0, 1)):
if len(image.sha... | [
"megengine.functional.vision.nms",
"megengine.functional.argmax",
"megengine.functional.squeeze",
"megengine.functional.zeros_like",
"megengine.functional.concat",
"megengine.functional.max"
] | [((475, 490), 'numpy.array', 'np.array', (['image'], {}), '(image)\n', (483, 490), True, 'import numpy as np\n'), ((1072, 1117), 'numpy.ascontiguousarray', 'np.ascontiguousarray', (['image'], {'dtype': 'np.float32'}), '(image, dtype=np.float32)\n', (1092, 1117), True, 'import numpy as np\n'), ((1234, 1258), 'megengine.... |
from pydantic.types import List, Optional
from sqlmodel import Field, Relationship, SQLModel
class TeamBase(SQLModel):
name: str
headquarters: str
class Config:
schema_extra = {
"example": {
"name": "wonderful league",
"headquarters": "Fortress of Solit... | [
"sqlmodel.Field",
"sqlmodel.Relationship"
] | [((410, 447), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (415, 447), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((476, 511), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""team"""'}), "(back_populates='t... |
# -*- 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.module.BatchNorm1d",
"megengine.core.tensor"
] | [((669, 708), 'megengine.module.BatchNorm1d', 'BatchNorm1d', (['nr_chan'], {'momentum': 'momentum'}), '(nr_chan, momentum=momentum)\n', (680, 708), False, 'from megengine.module import BatchNorm1d, BatchNorm2d\n'), ((728, 771), 'numpy.zeros', 'np.zeros', (['(1, nr_chan, 1)'], {'dtype': 'np.float32'}), '((1, nr_chan, 1)... |
"""user latest record
Revision ID: 7c2a518ed636
Revises: fe2df95ee61a
Create Date: 2021-11-27 15:37:54.561822
"""
import sqlalchemy as sa
import sqlmodel
import sqlmodel.sql.sqltypes
from alembic import op
# revision identifiers, used by Alembic.
revision = "7c2a518ed636"
down_revision = "fe2df95ee61a"
branch_labels... | [
"sqlmodel.sql.sqltypes.AutoString",
"sqlmodel.sql.sqltypes.GUID"
] | [((2542, 2593), 'alembic.op.drop_column', 'op.drop_column', (['"""problem_configs"""', '"""commit_message"""'], {}), "('problem_configs', 'commit_message')\n", (2556, 2593), False, 'from alembic import op\n'), ((2903, 2939), 'alembic.op.drop_table', 'op.drop_table', (['"""user_latest_records"""'], {}), "('user_latest_r... |
import numpy as nm
from sfepy.linalg import dot_sequences
from sfepy.terms.terms import Term, terms
class DivGradTerm(Term):
r"""
Diffusion term.
:Definition:
.. math::
\int_{\Omega} \nu\ \nabla \ul{v} : \nabla \ul{u} \mbox{ , }
\int_{\Omega} \nu\ \nabla \ul{u} : \nabla \ul{w} \\
... | [
"sfepy.linalg.dot_sequences"
] | [((11757, 11785), 'numpy.ascontiguousarray', 'nm.ascontiguousarray', (['div_bf'], {}), '(div_bf)\n', (11777, 11785), True, 'import numpy as nm\n'), ((1821, 1863), 'numpy.ones', 'nm.ones', (['(1, n_qp, 1, 1)'], {'dtype': 'nm.float64'}), '((1, n_qp, 1, 1), dtype=nm.float64)\n', (1828, 1863), True, 'import numpy as nm\n')... |
"""initial
Revision ID: a57c89b47e7b
Revises:
Create Date: 2021-11-01 04:27:56.134285
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = 'a57c89b47e7b'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### commands... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((1752, 1773), 'alembic.op.drop_table', 'op.drop_table', (['"""song"""'], {}), "('song')\n", (1765, 1773), False, 'from alembic import op\n'), ((1843, 1868), 'alembic.op.drop_table', 'op.drop_table', (['"""listings"""'], {}), "('listings')\n", (1856, 1868), False, 'from alembic import op\n'), ((1940, 1966), 'alembic.o... |
import numpy as np
import megengine.functional as F
from common import se3, so3
def compute_losses(endpoints, params):
loss = {}
# compute losses
if params.loss_type == "finet":
num_iter = len(endpoints["all_pose_pair"])
triplet_loss = {}
for i in range(num_iter):
# reg... | [
"megengine.functional.nn.l1_loss",
"megengine.functional.clip",
"megengine.functional.nn.square_loss",
"megengine.functional.mean",
"megengine.functional.norm",
"megengine.functional.abs",
"megengine.functional.concat"
] | [((3616, 3672), 'megengine.functional.mean', 'F.mean', (['((r_gt_euler_deg - r_pred_euler_deg) ** 2)'], {'axis': '(1)'}), '((r_gt_euler_deg - r_pred_euler_deg) ** 2, axis=1)\n', (3622, 3672), True, 'import megengine.functional as F\n'), ((3752, 3788), 'megengine.functional.mean', 'F.mean', (['((t_gt - t_pred) ** 2)'], ... |
from datetime import datetime
from typing import Optional
from fastapi import APIRouter, Depends
from sqlmodel import Field, SQLModel
from ..db import get_session
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
router = APIRouter()
class Procedure(SQLModel, table=True):
id: Optio... | [
"sqlmodel.Field"
] | [((254, 265), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (263, 265), False, 'from fastapi import APIRouter, Depends\n'), ((331, 368), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (336, 368), False, 'from sqlmodel import Field, SQLModel\n')... |
from __future__ import absolute_import
from sfepy.base.testing import TestCommon
def get_ortho_d(phi1, phi2):
import numpy as nm
import sfepy.mechanics.tensors as tn
v1 = nm.array([nm.cos(phi1), nm.sin(phi1), 0])
v2 = nm.array([nm.cos(phi2), nm.sin(phi2), 0])
om1 = nm.outer(v1, v1)
om2 = nm.ou... | [
"sfepy.mechanics.tensors.get_trace",
"sfepy.mechanics.tensors.get_full_indices",
"sfepy.mechanics.tensors.make_axis_rotation_matrix",
"sfepy.mechanics.tensors.get_sym_indices",
"sfepy.mechanics.tensors.transform_data",
"sfepy.mechanics.tensors.get_t4_from_t2s",
"sfepy.mechanics.tensors.get_deviator",
... | [((288, 304), 'numpy.outer', 'nm.outer', (['v1', 'v1'], {}), '(v1, v1)\n', (296, 304), True, 'import numpy as nm\n'), ((315, 331), 'numpy.outer', 'nm.outer', (['v2', 'v2'], {}), '(v2, v2)\n', (323, 331), True, 'import numpy as nm\n'), ((342, 363), 'sfepy.mechanics.tensors.get_sym_indices', 'tn.get_sym_indices', (['(3)'... |
from datetime import datetime
from sqlmodel import Field, SQLModel, Relationship
from typing import Optional
from sqlalchemy import Column
from sqlalchemy.dialects.postgresql import JSON
class TextInferenceBase(SQLModel):
text: str = Field(nullable=False, index=True)
class TextInference(TextInferenceBase, table... | [
"sqlmodel.Field",
"sqlmodel.Relationship"
] | [((240, 273), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'index': '(True)'}), '(nullable=False, index=True)\n', (245, 273), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((352, 405), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'nullable': '(False)', 'primary_key': '(True)'}), '(de... |
import pickle
from typing import Optional, Dict, Any, List, cast
from enum import Enum
import orjson
from fastapi import APIRouter, Depends, Query
from pydantic import validator
from sqlmodel import Session, Field, select # type: ignore[import]
from sqlalchemy import distinct # type: ignore[import]
from app.db im... | [
"sqlmodel.select",
"sqlmodel.Field"
] | [((363, 374), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (372, 374), False, 'from fastapi import APIRouter, Depends, Query\n'), ((473, 500), 'sqlmodel.Field', 'Field', ([], {'default_factory': 'list'}), '(default_factory=list)\n', (478, 500), False, 'from sqlmodel import Session, Field, select\n'), ((528, 553)... |
from datetime import timedelta
from enum import Enum
from tkinter import *
from tkinter import ttk
import typer
from sqlmodel import Session
class Status(str, Enum):
"""Status"""
to_do = 'to do'
doing = 'doing'
done = 'done'
def round_timedelta(delta: timedelta):
"""round timedelta object"""
... | [
"sqlmodel.Session"
] | [((1814, 1841), 'tkinter.ttk.Frame', 'ttk.Frame', (['root'], {'padding': '(10)'}), '(root, padding=10)\n', (1823, 1841), False, 'from tkinter import ttk\n'), ((827, 842), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (834, 842), False, 'from sqlmodel import Session\n'), ((2176, 2187), 'datetime.timedel... |
# -*- 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.loss.cross_entropy",
"megengine._full_sync",
"megengine.autodiff.GradManager",
"megengine.functional.debug_param.set_execution_strategy",
"megengine.jit.trace",
"megengine.amp.autocast",
"megengine.distributed.make_allreduce_cb",
"megengine.distributed.launcher",
"megengine.dtr... | [((941, 966), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (964, 966), False, 'import argparse\n'), ((1927, 1955), 'multiprocessing.set_start_method', 'mp.set_start_method', (['"""spawn"""'], {}), "('spawn')\n", (1946, 1955), True, 'import multiprocessing as mp\n'), ((1961, 1975), 'basecls.ut... |
r"""
Elastic contact sphere simulating an indentation test.
Find :math:`\ul{u}` such that:
.. math::
\int_{\Omega} D_{ijkl}\ e_{ij}(\ul{v}) e_{kl}(\ul{u})
+ \int_{\Gamma} \ul{v} \cdot f(d(\ul{u})) \ul{n}(\ul{u})
= 0 \;,
where
.. math::
D_{ijkl} = \mu (\delta_{ik} \delta_{jl} + \delta_{il} \delta_{jk... | [
"sfepy.discrete.fem.MeshIO.any_from_filename",
"sfepy.mechanics.contact_bodies.plot_points",
"sfepy.mechanics.contact_bodies.ContactSphere"
] | [((2053, 2078), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (2068, 2078), False, 'import os\n'), ((2088, 2148), 'sfepy.discrete.fem.MeshIO.any_from_filename', 'MeshIO.any_from_filename', (['filename_mesh'], {'prefix_dir': 'conf_dir'}), '(filename_mesh, prefix_dir=conf_dir)\n', (2112, 2148)... |
import numpy as nm
from sfepy.base.base import OneTypeList, Container, Struct
class Functions(Container):
"""Container to hold all user-defined functions."""
def from_conf(conf):
objs = OneTypeList(Function)
for key, fc in conf.iteritems():
fun = Function(name = fc.name,
... | [
"sfepy.base.base.OneTypeList",
"sfepy.base.base.Struct.__init__"
] | [((205, 226), 'sfepy.base.base.OneTypeList', 'OneTypeList', (['Function'], {}), '(Function)\n', (216, 226), False, 'from sfepy.base.base import OneTypeList, Container, Struct\n'), ((732, 808), 'sfepy.base.base.Struct.__init__', 'Struct.__init__', (['self'], {'name': 'name', 'function': 'function', 'is_constant': 'is_co... |
import random
from megengine.data.transform import RandomResizedCrop as mge_RRC
from megengine.data.transform import Resize as mge_resize
from ..registry import PIPELINES
from edit.utils import interp_codes
@PIPELINES.register_module()
class Resize(object):
"""
Args:
size (int|list|tuple): Desired ... | [
"megengine.data.transform.Resize",
"megengine.data.transform.RandomResizedCrop"
] | [((935, 1011), 'megengine.data.transform.Resize', 'mge_resize', ([], {'output_size': 'self.size', 'interpolation': 'interp_codes[interpolation]'}), '(output_size=self.size, interpolation=interp_codes[interpolation])\n', (945, 1011), True, 'from megengine.data.transform import Resize as mge_resize\n'), ((3160, 3277), 'm... |
from worker import writer, scanTemplates
from utils.manager import TrainManager
import time
from db import engine
from sqlmodel import Session
from models import Logrun,Usefuel, Template
import cachetool
import inspect
from disclog import postLog,postGeneric
def filler(posrr,posm) -> str:
start=time.time()
... | [
"sqlmodel.Session"
] | [((301, 312), 'time.time', 'time.time', ([], {}), '()\n', (310, 312), False, 'import time\n'), ((332, 368), 'utils.manager.TrainManager', 'TrainManager', ([], {'posrr': 'posrr', 'posm': 'posm'}), '(posrr=posrr, posm=posm)\n', (344, 368), False, 'from utils.manager import TrainManager\n'), ((416, 487), 'disclog.postGene... |
from __future__ import absolute_import
import numpy as nm
import numpy.linalg as nla
from sfepy.base.base import output, get_default, pause, Struct
from sfepy.base.log import Log, get_logging_conf
from sfepy.base.timing import Timer
from sfepy.solvers.solvers import OptimizationSolver
import scipy.optimize as sopt
i... | [
"sfepy.base.timing.Timer",
"sfepy.base.base.Struct",
"sfepy.base.base.get_default",
"sfepy.base.log.Log",
"sfepy.base.base.output",
"sfepy.solvers.solvers.OptimizationSolver.__init__",
"sfepy.base.log.get_logging_conf",
"sfepy.base.base.pause"
] | [((712, 778), 'sfepy.base.base.output', 'output', (["('opt: iter: %d, of: %e (||ofg||: %e)' % (it, of, ofg_norm))"], {}), "('opt: iter: %d, of: %e (||ofg||: %e)' % (it, of, ofg_norm))\n", (718, 778), False, 'from sfepy.base.base import output, get_default, pause, Struct\n'), ((1149, 1156), 'sfepy.base.timing.Timer', 'T... |
# This example implements homogenization of porous structures undergoing finite strains.
#
# largedef_porous_mac.py - problem at (global) macroscopic level
# largedef_porous_mic.py - local subproblems, homogenized coefficients
#
# The mathematical model and numerical results are described in:
#
# <NAME>., <NAME>.
# Ho... | [
"sfepy.base.base.Struct",
"sfepy.homogenization.micmac.get_homog_coefs_nonlinear",
"sfepy.linalg.dot_sequences",
"sfepy.base.base.output",
"sfepy.solvers.ts.TimeStepper"
] | [((968, 989), 'os.path.dirname', 'osp.dirname', (['__file__'], {}), '(__file__)\n', (979, 989), True, 'import os.path as osp\n'), ((3622, 3709), 'sfepy.base.base.output', 'output', (["('get_homog_mat: mode=%s, update=%s' % (mode, hyperela['update_materials']))"], {}), "('get_homog_mat: mode=%s, update=%s' % (mode, hype... |
"""
IGA domain generators.
"""
import numpy as nm
from sfepy.base.base import output, Struct
import sfepy.discrete.iga as iga
from sfepy.discrete.iga.domain import NurbsPatch
def gen_patch_block_domain(dims, shape, centre, degrees, continuity=None,
name='block', verbose=True):
"""
G... | [
"sfepy.discrete.iga.get_patch_box_regions",
"sfepy.base.base.output",
"sfepy.discrete.iga.combine_bezier_extraction",
"sfepy.base.base.Struct",
"sfepy.discrete.iga.compute_bezier_extraction",
"sfepy.discrete.iga.create_connectivity"
] | [((1252, 1286), 'numpy.asarray', 'nm.asarray', (['dims'], {'dtype': 'nm.float64'}), '(dims, dtype=nm.float64)\n', (1262, 1286), True, 'import numpy as nm\n'), ((1299, 1332), 'numpy.asarray', 'nm.asarray', (['shape'], {'dtype': 'nm.int32'}), '(shape, dtype=nm.int32)\n', (1309, 1332), True, 'import numpy as nm\n'), ((134... |
from typing import TYPE_CHECKING, List, Optional
from sqlmodel import Field, Relationship, SQLModel
if TYPE_CHECKING:
from .hero_model import Hero
class Team(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
headquarters: str
heroes: List["Hero"] = Relat... | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((213, 250), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (218, 250), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((315, 350), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""team"""'}), "(back_populates='t... |
# -*- 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.Graph",
"megengine.functional.relu",
"megengine.jit.trace",
"megengine.module.Linear"
] | [((1156, 1178), 'numpy.random.random', 'np.random.random', (['args'], {}), '(args)\n', (1172, 1178), True, 'import numpy as np\n'), ((747, 761), 'megengine.module.Linear', 'Linear', (['(28)', '(50)'], {}), '(28, 50)\n', (753, 761), False, 'from megengine.module import Linear, Module\n'), ((784, 798), 'megengine.module.... |
from datetime import date, datetime
from typing import Optional
from pydantic import BaseModel, validator
from sqlmodel import Field, SQLModel
# Simple classes for access control tokens
class Token(BaseModel):
access_token: str
token_type: str
expiry: datetime
class TokenData(BaseModel):
username: ... | [
"sqlmodel.Field"
] | [((445, 482), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (450, 482), False, 'from sqlmodel import Field, SQLModel\n'), ((566, 586), 'sqlmodel.Field', 'Field', ([], {'default': '(False)'}), '(default=False)\n', (571, 586), False, 'from sqlmodel im... |
from datetime import datetime, date
from decimal import Decimal
from typing import Optional, List
from fastapi import APIRouter, Depends
from sqlmodel import Field, SQLModel
from ...db import get_session
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
router = APIRouter()
class Histo... | [
"sqlmodel.Field"
] | [((295, 306), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (304, 306), False, 'from fastapi import APIRouter, Depends\n'), ((385, 422), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (390, 422), False, 'from sqlmodel import Field, SQLModel\n')... |
import time
import os
from typing import Optional
from sqlalchemy.exc import OperationalError
from sqlalchemy.engine import URL
from sqlmodel import Field, Session, SQLModel, create_engine, select
from loguru import logger
class Hero(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=Tru... | [
"sqlmodel.create_engine",
"sqlmodel.select",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field"
] | [((285, 322), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (290, 322), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((677, 788), 'sqlalchemy.engine.URL.create', 'URL.create', ([], {'drivername': '"""postgresql""... |
from sqlmodel import Field, Relationship, SQLModel
from typing import Optional
from app.models.base_uuid_model import BaseUUIDModel
from uuid import UUID
class HeroBase(SQLModel):
name: str = Field(index=True)
secret_name: str
age: Optional[int] = Field(default=None, index=True)
team_id: Optional[UUID]... | [
"sqlmodel.Field",
"sqlmodel.Relationship"
] | [((197, 214), 'sqlmodel.Field', 'Field', ([], {'index': '(True)'}), '(index=True)\n', (202, 214), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((261, 292), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'index': '(True)'}), '(default=None, index=True)\n', (266, 292), False, 'from sqlmodel import... |
# -*- coding: utf-8 -*-
# MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
#
# Copyright (c) 2014-2020 Megvii Inc. All rights reserved.
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT ARRANTI... | [
"megengine.functional.add_axis",
"megengine.functional.arange",
"megengine.functional.sigmoid",
"megengine.functional.abs",
"megengine.functional.exp"
] | [((1623, 1655), 'megengine.functional.arange', 'F.arange', (['(1)', '(logits.shape[2] + 1)'], {}), '(1, logits.shape[2] + 1)\n', (1631, 1655), True, 'import megengine.functional as F\n'), ((1670, 1696), 'megengine.functional.add_axis', 'F.add_axis', (['labels'], {'axis': '(2)'}), '(labels, axis=2)\n', (1680, 1696), Tru... |
from datetime import datetime
from typing import Optional
from fastapi import APIRouter, Depends
from sqlmodel import Field, SQLModel
from ...db import get_session
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
router = APIRouter()
class HistorySummaryTreatmsummaryConference(SQLMod... | [
"sqlmodel.Field"
] | [((256, 267), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (265, 267), False, 'from fastapi import APIRouter, Depends\n'), ((361, 398), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (366, 398), False, 'from sqlmodel import Field, SQLModel\n')... |
#!/usr/bin/env python
# 12.01.2007, c
import os.path as op
import shutil
from optparse import OptionParser
import sfepy
from sfepy.base.base import *
from sfepy.base.conf import ProblemConf, get_standard_keywords
from sfepy.fem import ProblemDefinition
from sfepy.fem.evaluate import assemble_by_blocks
from sfepy.homo... | [
"sfepy.homogenization.phono.detect_band_gaps",
"sfepy.fem.evaluate.assemble_by_blocks",
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.homogenization.engine.HomogenizationEngine",
"sfepy.homogenization.phono.plot_logs",
"sfepy.solvers.eig",
"sfepy.fem.ProblemDefinition.from_conf",
"sfepy.base.plotuti... | [((22108, 22171), 'optparse.OptionParser', 'OptionParser', ([], {'usage': 'usage', 'version': "('%prog ' + sfepy.__version__)"}), "(usage=usage, version='%prog ' + sfepy.__version__)\n", (22120, 22171), False, 'from optparse import OptionParser\n'), ((23535, 23558), 'sfepy.base.conf.get_standard_keywords', 'get_standar... |
import numpy as np
import megengine
import megengine.module as M
import megengine.functional as F
from edit.models.common import ShuffleV2Block, CoordAtt
import math
from . import default_init_weights
class MobileNeXt(M.Module):
def __init__(self, in_channels, out_channels, kernel_size=3):
"""
... | [
"megengine.module.ConvRelu2d",
"megengine.module.Sequential",
"megengine.module.Conv2d"
] | [((515, 639), 'megengine.module.ConvRelu2d', 'M.ConvRelu2d', (['in_channels', 'out_channels'], {'kernel_size': 'kernel_size', 'stride': '(1)', 'padding': '(kernel_size // 2)', 'groups': 'in_channels'}), '(in_channels, out_channels, kernel_size=kernel_size, stride=1,\n padding=kernel_size // 2, groups=in_channels)\n'... |
import typer
import uvicorn
from sqlmodel import Session, select
from .app import app
from .config import settings
from .db import create_db_and_tables, engine
from .models.content import Content
from .security import User
cli = typer.Typer(name="pythontasks API")
@cli.command()
def run(
port: int = settings.se... | [
"sqlmodel.Session"
] | [((231, 266), 'typer.Typer', 'typer.Typer', ([], {'name': '"""pythontasks API"""'}), "(name='pythontasks API')\n", (242, 266), False, 'import typer\n'), ((517, 614), 'uvicorn.run', 'uvicorn.run', (['"""pythontasks.app:app"""'], {'host': 'host', 'port': 'port', 'log_level': 'log_level', 'reload': 'reload'}), "('pythonta... |
"""
Friction-slip model formulated as the implicit complementarity problem.
To integrate over a (dual) mesh, one needs:
* coordinates of element vertices
* element connectivity
* local base for each element
* constant in each sub-triangle of the dual mesh
Data for each dual element:
* connectivity of its sub-tria... | [
"sfepy.fem.fe_surface.FESurface",
"sfepy.linalg.norm_l2_along_axis",
"sfepy.fem.utils.compute_nodal_normals",
"sfepy.base.compat.unique",
"sfepy.fem.Field",
"sfepy.fem.mappings.SurfaceMapping",
"sfepy.fem.mappings.VolumeMapping"
] | [((1918, 1968), 'sfepy.fem.Field', 'Field', (['"""displacements"""', 'nm.float64', '(3,)', 'omega', '(1)'], {}), "('displacements', nm.float64, (3,), omega, 1)\n", (1923, 1968), False, 'from sfepy.fem import Mesh, Domain, Field, Variables\n'), ((3178, 3239), 'sfepy.fem.utils.compute_nodal_normals', 'compute_nodal_norma... |
#!/usr/bin/env python3
# Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
from collections import namedtuple
from typing import Iterable, Union
import megengine as mge
import megengine.distributed as dist
import megengine.module as M
import megengine.optimizer as optim
from basecore.config import ConfigDict
fr... | [
"megengine.optimizer.SGD",
"megengine.optimizer.Adam",
"megengine.amp.GradScaler",
"megengine.optimizer.AdamW",
"megengine.autodiff.GradManager",
"megengine.distributed.make_allreduce_cb",
"megengine.distributed.get_world_size"
] | [((649, 715), 'collections.namedtuple', 'namedtuple', (['"""Solver"""', "['optimizer', 'grad_manager', 'grad_scaler']"], {}), "('Solver', ['optimizer', 'grad_manager', 'grad_scaler'])\n", (659, 715), False, 'from collections import namedtuple\n'), ((1267, 1295), 'basecls.utils.registers.solvers.register', 'registers.so... |
from typing import Any, Dict, List, Optional, Union
from pydantic.networks import EmailStr
from app.crud.base_sqlmodel import CRUDBase
from sqlmodel.ext.asyncio.session import AsyncSession
from sqlmodel import select
from app.schemas.user import IUserCreate, IUserUpdate
from app.models.user import User
from app.core.se... | [
"sqlmodel.select"
] | [((1751, 1768), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (1766, 1768), False, 'from datetime import datetime\n'), ((2751, 2798), 'app.core.security.verify_password', 'verify_password', (['password', 'user.hashed_password'], {}), '(password, user.hashed_password)\n', (2766, 2798), False, 'from ap... |
from typing import List
from fastapi import APIRouter, Depends
from sqlmodel import select, Session
from app.models import *
from utils import get_session
router = APIRouter()
@router.get("/users", response_model=List[UserRead])
async def get_users(*, session: Session=Depends(get_session)):
statement = select(Use... | [
"sqlmodel.select"
] | [((165, 176), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (174, 176), False, 'from fastapi import APIRouter, Depends\n'), ((271, 291), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (278, 291), False, 'from fastapi import APIRouter, Depends\n'), ((310, 322), 'sqlmodel.select', 'select',... |
from typing import List
from app.database import get_session
from app.models import Medication, MedicationUpdate
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlmodel import select
router = APIRouter(prefix="/medications", tags=["medications"])
@router.p... | [
"sqlmodel.select"
] | [((254, 308), 'fastapi.APIRouter', 'APIRouter', ([], {'prefix': '"""/medications"""', 'tags': "['medications']"}), "(prefix='/medications', tags=['medications'])\n", (263, 308), False, 'from fastapi import APIRouter, Depends, HTTPException\n'), ((432, 452), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_ses... |
"""seed schools
Revision ID: 8d04b7943264
Revises: <PASSWORD>
Create Date: 2022-04-18 00:38:38.618682+00:00
"""
import json
from os import getcwd
from pathlib import Path
import sqlalchemy as sa
import sqlalchemy.sql as sql
import sqlmodel
from alembic import context, op
# revision identifiers, used by Alembic.
rev... | [
"sqlmodel.sql.sqltypes.AutoString"
] | [((494, 521), 'sqlalchemy.sql.column', 'sql.column', (['"""id"""', 'sa.String'], {}), "('id', sa.String)\n", (504, 521), True, 'import sqlalchemy.sql as sql\n'), ((523, 552), 'sqlalchemy.sql.column', 'sql.column', (['"""name"""', 'sa.String'], {}), "('name', sa.String)\n", (533, 552), True, 'import sqlalchemy.sql as sq... |
from datetime import datetime
from typing import Optional
from pydantic import BaseSettings, HttpUrl
from sqlmodel import Field, SQLModel # pyright: ignore[reportUnknownVariableType]
class Post(SQLModel):
id: int
text: Optional[str]
photos: list[HttpUrl]
date: datetime
class PostDB(SQLModel, table... | [
"sqlmodel.Field"
] | [((342, 379), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (347, 379), False, 'from sqlmodel import Field, SQLModel\n')] |
#!/usr/bin/env python
# 12.01.2007, c
"""
Solve partial differential equations given in a SfePy problem definition file.
Example problem definition files can be found in ``examples/`` directory of the
SfePy top-level directory. This script works with all the examples except those
in ``examples/standalone/``.
Both nor... | [
"sfepy.base.conf.get_standard_keywords",
"sfepy.solvers.solver_table.keys",
"sfepy.base.conf.ProblemConf.from_file_and_options",
"sfepy.base.base.output.set_output",
"sfepy.applications.PDESolverApp",
"sfepy.base.base.debug_on_error"
] | [((2913, 2998), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '__doc__', 'formatter_class': 'RawDescriptionHelpFormatter'}), '(description=__doc__, formatter_class=RawDescriptionHelpFormatter\n )\n', (2927, 2998), False, 'from argparse import ArgumentParser, RawDescriptionHelpFormatter\n'), ((668... |
from typing import Optional
from sqlmodel import Session
from db.base import engine
from db.models import Plant
def create_plants():
plant_1 = Plant(name="Hebe")
plant_2 = Plant(name="Astilbe")
plant_3 = Plant(name="Sedum")
plant_4 = Plant(name="Helenium")
plant_5 = Plant(name="Heather")
ses... | [
"sqlmodel.Session"
] | [((150, 168), 'db.models.Plant', 'Plant', ([], {'name': '"""Hebe"""'}), "(name='Hebe')\n", (155, 168), False, 'from db.models import Plant\n'), ((183, 204), 'db.models.Plant', 'Plant', ([], {'name': '"""Astilbe"""'}), "(name='Astilbe')\n", (188, 204), False, 'from db.models import Plant\n'), ((219, 238), 'db.models.Pla... |
from typing import TYPE_CHECKING, Any, Dict, Optional
from uuid import UUID
from sqlalchemy.schema import Column, ForeignKey
from sqlmodel import Field, Relationship, select
from sqlmodel.sql.sqltypes import GUID
from joj.horse.models.base import BaseORMModel
from joj.horse.services.db import db_session
from joj.hors... | [
"sqlmodel.Field",
"sqlmodel.select",
"sqlmodel.Relationship"
] | [((558, 565), 'sqlmodel.Field', 'Field', ([], {}), '()\n', (563, 565), False, 'from sqlmodel import Field, Relationship, select\n'), ((590, 597), 'sqlmodel.Field', 'Field', ([], {}), '()\n', (595, 597), False, 'from sqlmodel import Field, Relationship, select\n'), ((633, 659), 'sqlmodel.Field', 'Field', (['None'], {'nu... |
from __future__ import absolute_import
from sfepy import data_dir
import six
filename_mesh = data_dir + '/meshes/3d/special/cube_cylinder.mesh'
if 0:
from sfepy.discrete.fem.utils import refine_mesh
refinement_level = 1
filename_mesh = refine_mesh(filename_mesh, refinement_level)
material_2 = {
'name... | [
"sfepy.discrete.Problem.from_conf",
"sfepy.discrete.fem.utils.refine_mesh",
"sfepy.solvers.Solver.any_from_conf",
"sfepy.discrete.state.State",
"sfepy.base.base.IndexedStruct"
] | [((250, 294), 'sfepy.discrete.fem.utils.refine_mesh', 'refine_mesh', (['filename_mesh', 'refinement_level'], {}), '(filename_mesh, refinement_level)\n', (261, 294), False, 'from sfepy.discrete.fem.utils import refine_mesh\n'), ((4007, 4030), 'sfepy.discrete.Problem.from_conf', 'Problem.from_conf', (['conf'], {}), '(con... |
# -*- 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.Linear",
"megengine.quantization.quantize.quantize_qat",
"megengine.module.QuantStub",
"megengine.Parameter",
"megengine.functional.relu",
"megengine.module.DequantStub",
"megengine.jit.tracing.trace",
"megengine.core.tensor.megbrain_graph.load_graph",
"megengine.utils.naming.AutoN... | [((1296, 1346), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False, True])\n", (1319, 1346), False, 'import pytest\n'), ((1708, 1758), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""symbolic"""', '[False, True]'], {}), "('symbolic', [False,... |
from typing import Optional
from sqlmodel import Field, SQLModel, Field
from pydantic import root_validator
from datetime import datetime
# {
# "user_id": 1,
# "start_time": "2022-01-19T08:30:00.000Z",
# "end_time": "2022-01-19T09:30:00.000Z",
# "client_id": 1,
# "epic_id": 1,
# "count_hours": 0,
# "cou... | [
"sqlmodel.Field"
] | [((473, 510), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (478, 510), False, 'from sqlmodel import Field, SQLModel, Field\n'), ((530, 568), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""app_db.appuser.id"""'}), "(foreign_key='app_db.appuser.... |
from create_db import Student
from sqlmodel import Session, create_engine, select
sqlite_url = "sqlite:///school.db"
engine = create_engine(sqlite_url, echo=True)
# Read database
with Session(engine) as session:
statement = select(Student)
results = session.exec(statement)
for student in results:
... | [
"sqlmodel.select",
"sqlmodel.Session",
"sqlmodel.create_engine"
] | [((127, 163), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (140, 163), False, 'from sqlmodel import Session, create_engine, select\n'), ((186, 201), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (193, 201), False, 'from sqlmodel import Se... |
# -*- coding: utf-8 -*-
# MIT License
#
# Copyright (c) 2021 coolbeam
#
# 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
# to use, ... | [
"megengine.functional.sigmoid",
"megengine.functional.expand_dims",
"megengine.module.BatchNorm2d",
"megengine.functional.vision.interpolate",
"megengine.module.InstanceNorm",
"megengine.functional.concat",
"megengine.module.Conv2d",
"megengine.module.LeakyReLU"
] | [((5825, 5856), 'common.utils.flow_warp', 'flow_warp', (['feature_2', 'flow_init'], {}), '(feature_2, flow_init)\n', (5834, 5856), False, 'from common.utils import flow_warp, upsample2d_flow_as\n'), ((5881, 5926), 'megengine.functional.concat', 'F.concat', (['(feature_1, feature_2_warp)'], {'axis': '(1)'}), '((feature_... |
from datetime import datetime, date , time
from typing import Optional, List
from fastapi import APIRouter, Depends
from sqlmodel import Field, SQLModel
from ...db import get_session
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
router = APIRouter()
class HistoryAppointmentOr(SQLMo... | [
"sqlmodel.Field"
] | [((274, 285), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (283, 285), False, 'from fastapi import APIRouter, Depends\n'), ((362, 399), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (367, 399), False, 'from sqlmodel import Field, SQLModel\n')... |
from typing import Optional
from pydantic import condecimal
from sqlalchemy.orm import declared_attr
from sqlmodel import Field, SQLModel
class Reward(SQLModel, table=True):
tx_hash: Optional[str] = Field(primary_key=True)
address: Optional[str] = Field(..., index=True)
block: Optional[int]
timestamp... | [
"sqlmodel.Field"
] | [((206, 229), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (211, 229), False, 'from sqlmodel import Field, SQLModel\n'), ((259, 281), 'sqlmodel.Field', 'Field', (['...'], {'index': '(True)'}), '(..., index=True)\n', (264, 281), False, 'from sqlmodel import Field, SQLModel\n'), ((3... |
from typing import Optional
from sqlmodel import Field, SQLModel
class UserBase(SQLModel):
name: str
class User(UserBase, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
class UserCreate(UserBase):
pass
class UserRead(UserBase):
id: int
| [
"sqlmodel.Field"
] | [((168, 205), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (173, 205), False, 'from sqlmodel import Field, SQLModel\n')] |
import asyncio
import pytest
from sqlalchemy.ext.asyncio import create_async_engine
from sqlalchemy.ext.asyncio.engine import AsyncConnection
from sqlmodel.ext.asyncio.session import AsyncSession
from basesqlmodel import Base
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
@pytest.fixture()
async def ... | [
"sqlmodel.ext.asyncio.session.AsyncSession"
] | [((238, 289), 'sqlalchemy.ext.asyncio.create_async_engine', 'create_async_engine', (['"""sqlite+aiosqlite:///:memory:"""'], {}), "('sqlite+aiosqlite:///:memory:')\n", (257, 289), False, 'from sqlalchemy.ext.asyncio import create_async_engine\n'), ((293, 309), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (307, ... |
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# Copyright (c) Megvii, Inc. and its affiliates.
import argparse
import megengine as mge
import numpy as np
from megengine import jit
from ..build import build_and_load
def make_parser():
parser = argparse.ArgumentParser("YOLOX Demo Dump")
parser.add_argument("... | [
"megengine.jit.trace"
] | [((252, 294), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""YOLOX Demo Dump"""'], {}), "('YOLOX Demo Dump')\n", (275, 294), False, 'import argparse\n'), ((780, 812), 'megengine.jit.trace', 'jit.trace', ([], {'capture_as_const': '(True)'}), '(capture_as_const=True)\n', (789, 812), False, 'from megengine im... |
"""
Node related APIs.
"""
import logging
from datetime import datetime
from typing import List, Optional
from fastapi import APIRouter, Depends
from sqlmodel import Session, SQLModel, select
from datajunction.models.column import ColumnType
from datajunction.models.node import Node, NodeType
from datajunction.utils... | [
"sqlmodel.select"
] | [((351, 378), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (368, 378), False, 'import logging\n'), ((388, 399), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (397, 399), False, 'from fastapi import APIRouter, Depends\n'), ((946, 966), 'fastapi.Depends', 'Depends', (['get_session']... |
import numpy as np
from sfepy.base.conf import ProblemConf
from sfepy.discrete.problem import Problem
from sfepy.mesh.mesh_generators import gen_block_mesh
from sfepy.postprocess.viewer import Viewer
from scipy.interpolate import interpn
import matplotlib.pyplot as plt
from matplotlib import ticker
... | [
"sfepy.base.conf.ProblemConf.from_file",
"sfepy.mesh.mesh_generators.gen_block_mesh",
"sfepy.postprocess.viewer.Viewer",
"sfepy.discrete.problem.Problem.from_conf"
] | [((1057, 1073), 'numpy.array', 'np.array', (['[2, 2]'], {}), '([2, 2])\n', (1065, 1073), True, 'import numpy as np\n'), ((2094, 2121), 'numpy.divide', 'np.divide', (['dims', 'cell_sizes'], {}), '(dims, cell_sizes)\n', (2103, 2121), True, 'import numpy as np\n'), ((2212, 2255), 'sfepy.mesh.mesh_generators.gen_block_mesh... |
# 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.module.ReLU",
"megengine.module.BatchNorm2d",
"megengine.functional.avg_pool2d",
"megengine.functional.relu",
"megengine.module.init.xavier_uniform_",
"megengine.functional.interpolate",
"megengine.module.Conv2d"
] | [((2136, 2201), 'megengine.module.Conv2d', 'M.Conv2d', (['self.in_channels', 'self.hidden_channels', '(3)', '(1)'], {'padding': '(1)'}), '(self.in_channels, self.hidden_channels, 3, 1, padding=1)\n', (2144, 2201), True, 'import megengine.module as M\n'), ((2328, 2394), 'megengine.module.Conv2d', 'M.Conv2d', (['self.hid... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.