from sage.misc.lazy_import import lazy_import
lazy_import('sage.manifolds.manifold', 'Manifold')

from graded_algebras      import GradedAlgebras
from graded_coalgebras    import GradedCoalgebras
from graded_bialgebras    import GradedBialgebras
from graded_hopf_algebras import GradedHopfAlgebras

# graded * with basis
from graded_modules_with_basis       import GradedModulesWithBasis
from graded_algebras_with_basis      import GradedAlgebrasWithBasis
from graded_coalgebras_with_basis    import GradedCoalgebrasWithBasis
from graded_bialgebras_with_basis    import GradedBialgebrasWithBasis
from graded_hopf_algebras_with_basis import GradedHopfAlgebrasWithBasis


# coxeter groups
from coxeter_groups import CoxeterGroups
from finite_coxeter_groups import FiniteCoxeterGroups
from weyl_groups import WeylGroups
from finite_weyl_groups import FiniteWeylGroups
from affine_weyl_groups import AffineWeylGroups

# crystal bases
from crystals import Crystals
from highest_weight_crystals import HighestWeightCrystals
from regular_crystals import RegularCrystals
from finite_crystals import FiniteCrystals
from classical_crystals import ClassicalCrystals

# polyhedra
from sage.misc.lazy_import import lazy_import
lazy_import('sage.categories.polyhedra', 'PolyhedralSets')

from sage.misc.lazy_import import lazy_import
lazy_import("sage.dynamics.interval_exchanges", "constructors", "iet")

from sage.misc.lazy_import import lazy_import
lazy_import('sage.rings.semirings.non_negative_integer_semiring',
            ['NonNegativeIntegerSemiring', 'NN'])

from sql_db import SQLQuery, SQLDatabase

from conway import ConwayPolynomials

from cremona import CremonaDatabase

from jones import JonesDatabase

from stein_watkins import SteinWatkinsAllData, SteinWatkinsPrimeData

from install import database_install

from sloane import sloane_sequence, sloane_find, SloaneEncyclopedia

from sage.misc.lazy_import import lazy_import
lazy_import('sage.databases.oeis', 'oeis')

from symbolic_data import SymbolicData

# commented out, since it's broken -- nobody updated the parser
# for the new format; nobody complained it didn't work, so it
# can't be that important.
#from lincodes import linear_code_bound

from odlyzko import zeta_zeros

from db_modular_polynomials import \
     ClassicalModularPolynomialDatabase, \
     DedekindEtaModularPolynomialDatabase, \
     DedekindEtaModularCorrespondenceDatabase, \
     AtkinModularPolynomialDatabase, \

import sage.libs.ntl.all  as ntl

from sage.libs.pari.all   import pari, pari_gen, allocatemem, PariError

from sage.libs.mwrank.all  import (mwrank_EllipticCurve, mwrank_MordellWeil,
                                   mwrank_initprimes,
                                   get_precision as mwrank_get_precision,
                                   set_precision as mwrank_set_precision)


import symmetrica.all as symmetrica

from cremona.all import CremonaModularSymbols


from sage.misc.lazy_import import lazy_import
lazy_import('sage.libs.gap.libgap', 'libgap')

from sage.misc.lazy_import import lazy_import
lazy_import('sage.manifolds.manifold', 'Manifold')
lazy_import('sage.manifolds.differentiable.real_line', 'OpenInterval')
lazy_import('sage.manifolds.differentiable.real_line', 'RealLine')

from bar_chart import bar_chart
from histogram import histogram
from bezier_path import bezier_path
from scatter_plot import scatter_plot
from disk import disk
from point import point, points, point2d
from matrix_plot import matrix_plot
from plot_field import plot_vector_field, plot_slope_field
from text import text
from polygon import polygon, polygon2d
from circle import circle
from ellipse import ellipse
from contour_plot import contour_plot, implicit_plot, region_plot
from density_plot import density_plot

from sage.misc.lazy_import import lazy_import
lazy_import("sage.plot.complex_plot",["complex_plot"])

from arc import arc

from animate import animate

from plot3d.tachyon import Tachyon

from colors import Color, hue, rainbow, colors, colormaps

from step import plot_step_function

from hyperbolic_arc import hyperbolic_arc
from hyperbolic_polygon import hyperbolic_triangle, hyperbolic_polygon

from functional import (diff, derivative,
                        expand,
                        taylor, simplify)

from functions import (wronskian,jacobian)

from desolvers import (desolve, desolve_laplace, desolve_system,
                       eulers_method, eulers_method_2x2, 
                       eulers_method_2x2_plot, desolve_rk4, desolve_system_rk4, 
                       desolve_odeint)

from var import (var, function, clear_vars)

# We lazy_import the following modules since they import numpy which slows down sage startup
from sage.misc.lazy_import import lazy_import
lazy_import("sage.calculus.riemann",["Riemann_Map"])
lazy_import("sage.calculus.interpolators",["polygon_spline","complex_cubic_spline"])

from sage.modules.all import vector

def symbolic_expression(x):
    """
    Create a symbolic expression or vector of symbolic expressions from x.

    INPUT:

    - ``x`` - an object

    OUTPUT:

    - a symbolic expression.

from sage.misc.lazy_import import lazy_import

lazy_import("sage.coding.code_constructions", ["permutation_action",
            "walsh_matrix"])

from sage.misc.superseded import deprecated_callable_import

deprecated_callable_import(19315,
            "sage.coding.code_bounds",
            globals(),
            locals(),
            ["codesize_upper_bound",
            "dimension_upper_bound",
            "volume_hamming",
            "gilbert_lower_bound",
            "plotkin_upper_bound",
            "griesmer_upper_bound",
            "elias_upper_bound",
            "hamming_upper_bound",
            "singleton_upper_bound",
            "gv_info_rate",
            "entropy",
            "gv_bound_asymp",
            "hamming_bound_asymp",
            "singleton_bound_asymp",
            "plotkin_bound_asymp",
            "elias_bound_asymp",
            "mrrw1_bound_asymp"],
            ("This method soon will not be available in that way."
            "Please call codes.bounds.%(name)s instead"))

from pari_group import PariGroup

from matrix_gps.all import (GL, SL, Sp, SU, GU, SO, GO,
                            MatrixGroup, is_MatrixGroup,
                            is_MatrixGroupElement)
from abelian_gps.all import *

from perm_gps.all import *

from generic import *

from class_function import ClassFunction

from additive_abelian.all import *

from conjugacy_classes import *

from sage.misc.lazy_import import lazy_import

lazy_import('sage.groups.free_group', 'FreeGroup')
lazy_import('sage.groups.braid', 'BraidGroup')

import groups_catalog as groups

from tuple import Tuples, UnorderedTuples

#Alternating sign matrices
from alternating_sign_matrix import AlternatingSignMatrix, AlternatingSignMatrices, MonotoneTriangles, ContreTableaux, TruncatedStaircases

# Parking Functions
from non_decreasing_parking_function import NonDecreasingParkingFunctions, NonDecreasingParkingFunction
from parking_functions import ParkingFunctions, ParkingFunction

# Trees and Tamari interval posets
from sage.misc.lazy_import import lazy_import
from ordered_tree import (OrderedTree, OrderedTrees,
                          LabelledOrderedTree, LabelledOrderedTrees)
from binary_tree import (BinaryTree, BinaryTrees,
                         LabelledBinaryTree, LabelledBinaryTrees)
lazy_import('sage.combinat.interval_posets', ['TamariIntervalPoset', 'TamariIntervalPosets'])

from combination import Combinations
from cartesian_product import CartesianProduct

from set_partition import SetPartition, SetPartitions
from set_partition_ordered import OrderedSetPartition, OrderedSetPartitions
from subset import Subsets
#from subsets_pairwise import PairwiseCompatibleSubsets
from necklace import Necklaces
from lyndon_word import LyndonWord, LyndonWords, StandardBracketedLyndonWords
from dyck_word import DyckWords, DyckWord
from sloane_functions import sloane

from root_system.all import *
from sf.all import *

from sage.misc.lazy_import import lazy_import
lazy_import('sage.rings.asymptotic.asymptotic_ring', 'AsymptoticRing')
lazy_import('sage.rings.asymptotic.asymptotic_expansion_generators', 'asymptotic_expansions')

# code exports

from fano_variety import CPRFanoToricVariety
from ideal import ToricIdeal
from library import toric_varieties
from variety import AffineToricVariety, ToricVariety

from sage.misc.lazy_import import lazy_import

lazy_import("sage.schemes.toric.weierstrass", "WeierstrassForm")

    Moebius, Hirzebruch_Jung_continued_fraction_list, dedekind_sum, \
    prime_factors


from fast_arith import prime_range

from bernoulli_mod_p import bernoulli_mod_p, bernoulli_mod_p_single

from monomials import monomials

#from fast_polynomial.compiled_polynomial import compiled_polynomial

CC = ComplexField()
CIF = ComplexIntervalField()

# i = I = QuadraticField(-1, 'I').gen()
I = CC.gen()

from residue_field import ResidueField


from misc import composite_field

import tests

# Universal Cyclotomic Field
from sage.rings.universal_cyclotomic_field.all import *

from sage.misc.lazy_import import lazy_import
lazy_import('sage.rings.invariant_theory', 'invariant_theory')

from sage.misc.lazy_import import lazy_import

lazy_import('sage.groups.matrix_gps.linear', 'GL')
lazy_import('sage.groups.matrix_gps.linear', 'SL')
lazy_import('sage.groups.matrix_gps.symplectic', 'Sp')
lazy_import('sage.groups.matrix_gps.unitary', 'SU')
lazy_import('sage.groups.matrix_gps.unitary', 'GU')
lazy_import('sage.groups.matrix_gps.orthogonal', 'GO')
lazy_import('sage.groups.matrix_gps.orthogonal', 'SO')
lazy_import('sage.groups.matrix_gps.finitely_generated', 'MatrixGroup')
lazy_import('sage.groups.matrix_gps.finitely_generated', 'QuaternionMatrixGroupGF3')

import sage.groups.matrix_gps.pickling_overrides

from sage.misc.lazy_import import lazy_import
lazy_import('sage.arith.all', '*', deprecation=19879)

r"""
Symmetric function features that are imported by default in the interpreter namespace
"""
from __future__ import absolute_import

from sage.misc.lazy_import import lazy_import

# In the long run, this will be the single entry point
# Nothing else will be exported
from .sf import SymmetricFunctions

# Advanced stuff:

lazy_import('sage.combinat.sf.kfpoly', 'KostkaFoulkesPolynomial')

from .ns_macdonald import NonattackingFillings, AugmentedLatticeDiagramFilling, LatticeDiagram

from sage.structure.unique_representation import UniqueRepresentation
from sage.structure.element import FieldElement, parent
from sage.structure.coerce import py_scalar_to_element

from sage.rings.ring import Field

from sage.rings.integer import Integer
from sage.rings.rational import Rational

from sage.rings.integer_ring import ZZ
from sage.rings.rational_field import QQ
from sage.rings.infinity import Infinity

# Deprecations from the old universal cyclotomic field
from sage.misc.lazy_import import lazy_import
lazy_import("sage.rings", "universal_cyclotomic_field", deprecation=18152)

libgap = GapElement_Integer = GapElement_Rational = GapElement_Cyclotomic = None
gap = gap3 = None

def late_import():
    r"""
    This function avoids importing libgap on startup. It is called once through
    the constrcturo of :class:`UniversalCyclotomicField`.

    EXAMPLES::

        sage: import sage.rings.universal_cyclotomic_field as ucf
        sage: _ = UniversalCyclotomicField()   # indirect doctest
        sage: ucf.libgap is None               # indirect doctest
        False

"""
Crystal features that are imported by default in the interpreter namespace
"""
from __future__ import absolute_import

from sage.misc.lazy_import import lazy_import

lazy_import('sage.combinat.crystals', 'catalog', 'crystals')