Module Hierarchy

• gavo: DaCHS code; most of this is support code for running a data center within the Virtual Observatory (VO), but some packages are interesting for VO clients as well.
  • gavo.adql: Parsing, annotating, and morphing queries in the Astronomical Data Query Language.
    • gavo.adql.annotations: Adding field infos to columns and other objects in an ADQL parse tree.
    • gavo.adql.common: Exceptions and helper functions for ADQL processing.
    • gavo.adql.fieldinfo: Field Infos -- annotations to ADQL parse nodes carrying values.
    • gavo.adql.fieldinfos: FieldInfos are collections of inferred metadata on the columns present within ADQL relations.
    • gavo.adql.grammar: A parser for ADQL.
    • gavo.adql.morphhelpers: Helpers for morphing modules
    • gavo.adql.morphpg: Morphing ADQL into queries that postgres/pgSphere can understand.
    • gavo.adql.nodes: Node classes and factories used in ADQL tree processing.
    • gavo.adql.postproc: Operations on annotated ADQL trees done by parseAnnotated.
    • gavo.adql.tree: Trees of ADQL expressions and operations on them.
    • gavo.adql.ufunctions: "User" defined functions, i.e., ADQL functions defined only on this system.
  • gavo.api: This should evolve into a useful API to GAVO code for more-or-less external clients.
  • gavo.base: Basic code for defining objects in the data center: Structures, their attributes, fundamental VO conventions.
    • gavo.base.activetags: Active tags are used in prepare and insert computed material into RD trees.
    • gavo.base.attrdef: Attribute definitions for structures.
    • gavo.base.caches: Accessor functions for the various immutables we have.
    • gavo.base.common: Common code for DaCHS's base package.
    • gavo.base.complexattrs: Attributes with structure (i.e., containing structures or more than one atom).
    • gavo.base.config: Definition of DC config options and their management including I/O.
    • gavo.base.coords: (Mostly deprecated) code to handle coordinate systems and transform between them.
    • gavo.base.cron: A cron-like facility to regularly run some functions.
    • gavo.base.events: General event handling.
    • gavo.base.literals: Functions taking strings and returning python values.
    • gavo.base.macros: A macro mechanism primarily for string replacement in resource descriptors.
    • gavo.base.meta: Code dealing with meta information.
    • gavo.base.metavalidation: Meta information validation.
    • gavo.base.observer: Observers are objects listening to EventDispatchers.
    • gavo.base.osinter: Basic OS interface/utility functions that depend on our configuration.
    • gavo.base.parsecontext: ParseContexts for parsing into structures.
    • gavo.base.sqlmunge: Helpers for building SQL expressions.
    • gavo.base.sqlsupport: Basic support for communicating with the database server.
    • gavo.base.structure: Representation of structured data deserializable from XML.
    • gavo.base.typesystems: Conversions between type systems.
    • gavo.base.unitconv: A python module to parse VOUnit strings and compute conversion factors.
    • gavo.base.valuemappers: Serialising table rows.
    • gavo.base.xmlstruct: Code to parse structures from XML sources.
  • gavo.dm: GAVO's VO-DML+VOTable library.
    • gavo.dm.annotations: The specialised annotations for the various entities of VO-DML.
    • gavo.dm.common: Common code for new-style Data Model support.
    • gavo.dm.dmrd: Writing annotations in RDs.
    • gavo.dm.sil: SIL, the Simple Instance Language, is an attempt to allow data model instances written in a simple, JSON-like language.
    • gavo.dm.vodml: Parsing VO-DML files and validating against the rules obtained in this way.
  • gavo.formats: Output formats.
    • gavo.formats.common: Common code for generation of various data formats.
    • gavo.formats.csvtable: Wrinting data in CSV.
    • gavo.formats.fitstable: Writing data in FITS binary tables
    • gavo.formats.geojson: Generating geojson (RFC 7946) files.
    • gavo.formats.jsontable: Writing tables in JSON.
    • gavo.formats.texttable: Writing data as plain text.
    • gavo.formats.votable: A facade for parsing and generating VOTables to and from internal data representations.
    • gavo.formats.votableread: Parsing and translating VOTables to internal data structures.
    • gavo.formats.votablewrite: Generating VOTables from internal data representations.
  • gavo.grammars: Grammars for parsing sources.
    • gavo.grammars.binarygrammar: A grammar reading from (fixed-record) binary files.
    • gavo.grammars.cdfgrammar: A grammar wrapping spacepy to parse files in the Common Data Format (CDF), http://cdf.gsfc.nasa.gov.
    • gavo.grammars.columngrammar: A grammar that just splits the source into input lines and then lets you name character ranges.
    • gavo.grammars.common: Base classes and common code for grammars.
    • gavo.grammars.csvgrammar: A grammar using python's csv module to parse files.
    • gavo.grammars.customgrammar: A grammar that imports a user-defined module and takes the RowIterator from there.
    • gavo.grammars.dictlistgrammar: A (quite trivial) grammar that iterates over lists of dicts.
    • gavo.grammars.directgrammar: A grammar supporting C language boosters (or possibly other mechanisms bypassing internal dbtable).
    • gavo.grammars.embeddedgrammar: A grammars defined by code embedded in the RD.
    • gavo.grammars.fitsprodgrammar: A grammar to parse from primary FITS headers.
    • gavo.grammars.fitstablegrammar: A grammar taking rows from a FITS table.
    • gavo.grammars.freeregrammar: A grammar based on repeated application of REs
    • gavo.grammars.kvgrammar: A grammar parsing key-value pairs from plain text files.
    • gavo.grammars.mysqldumpgrammar: A q'n'd grammar for reading MySQL dumps of moderate size.
    • gavo.grammars.odbcgrammar: A Grammar feeding from an odbc connection.
    • gavo.grammars.pdsgrammar: A grammar wrapping pypds to parse files in the format of the planetary data system (PDS).
    • gavo.grammars.regrammar: A grammar splitting the input file into lines and lines into records using REs.
    • gavo.grammars.rowsetgrammar: A grammar that takes standard tuples as input and turns them into rows of a table.
    • gavo.grammars.votablegrammar: A grammar taking its rows from a VOTable.
  • gavo.helpers: Code to support DC-external code (preprocessing, testing...)
    • gavo.helpers.anet: Code to obtain WCS headers for FITS files using astrometry.net
    • gavo.helpers.copying: Helpers for pulling data from CDs, DVDs and similar media.
    • gavo.helpers.filestuff: File- and directory related helpers for resource utilites.
    • gavo.helpers.fitstricks: Helpers for manipulating FITS files.
    • gavo.helpers.processing: An abstract processor and some helping code.
    • gavo.helpers.testhelpers: Helper classes for the DaCHS' unit tests.
    • gavo.helpers.testtricks: Helper functions and classes for unit tests and similar.
    • gavo.helpers.trialhelpers: Helpers for trial-based tests, in particular retrieving pages.
  • gavo.imp
    • gavo.imp.formal
      • gavo.imp.formal.types
      • gavo.imp.formal.validation
      • gavo.imp.formal.widget
      • gavo.imp.formal.widgets
        • gavo.imp.formal.widgets.restwidget
        • gavo.imp.formal.widgets.multiselect
        • gavo.imp.formal.widgets.richtextarea
  • gavo.protocols: IVOA, W3C, and custom protocol helpers (in cooperation with twisted-based code in weg).
    • gavo.protocols.adqlglue: Code to bind the adql library to the data center software.
    • gavo.protocols.creds: Code for checking against our user db.
    • gavo.protocols.dali: Common code supporting functionality described in DALI.
    • gavo.protocols.datalink: The datalink core and its numerous helper classes.
    • gavo.protocols.dlasync: A UWS-based interface to datalink.
    • gavo.protocols.gavolog: Helper code for logging to files.
    • gavo.protocols.oaiclient: A simple client of OAI-http.
    • gavo.protocols.products: Products and a core turning accrefs into lists of products.
    • gavo.protocols.scs: IVOA cone search: Helper functions, a core, and misc.
    • gavo.protocols.sdm: Code dealing with spectra (the actual data), in particular in the spectral data model (sdm).
    • gavo.protocols.siap: Support code for the Simple Image Access Protocol.
    • gavo.protocols.simbadinterface: A caching proxy for CDS' Simbad object resolver.
    • gavo.protocols.soda: Helper functions for SODA manipulators.
    • gavo.protocols.ssap: The SSAP core and supporting code.
    • gavo.protocols.tap: TAP: schema maintenance, job/parameter definition incl.
    • gavo.protocols.taprunner: Execution of UWS (right now, TAP only) requests.
    • gavo.protocols.useruws: Support for UWSes defined in user RDs.
    • gavo.protocols.uws: Support classes for the universal worker service.
    • gavo.protocols.uwsactions: Manipulating UWS jobs through a REST interface.
  • gavo.registry: Registry interface: service list, record generation, OAI endpoint.
    • gavo.registry.builders: Functions returning xmlstan for various OAI/VOR documents.
    • gavo.registry.capabilities: VOResource capability/interface elements.
    • gavo.registry.common: Common code and definitions for registry support.
    • gavo.registry.identifiers: Parsing identifiers, getting res tuples and resobs from them.
    • gavo.registry.model: The schema and XML namespaces for OAI/VOR documents.
    • gavo.registry.nonservice: Resources that are not services.
    • gavo.registry.oaiinter: The standard OAI interface.
    • gavo.registry.publication: "Publishing" service records -- grammar-type stuff and UI.
    • gavo.registry.servicelist: The (DC-internal) service list: querying, adding records, etc.
    • gavo.registry.tableset: Generation of VODataService 1.1 tablesets from resources.
  • gavo.rsc: Instantiated resources (tables, etc), plus data mangling.
    • gavo.rsc.common: Helpers for resource creation.
    • gavo.rsc.data: Making data out of descriptors and sources.
    • gavo.rsc.dbtable: Tables on disk
    • gavo.rsc.dumping: DaCHS supports dump/restore operations on tables or set of tables.
    • gavo.rsc.metatable: Handling table metadata in the dc.(table|column)meta tables.
    • gavo.rsc.qtable: A table representing a query.
    • gavo.rsc.table: Tables, base and in memory.
    • gavo.rsc.tables: Common interface to table implementations.
  • gavo.rscdef: Resources and their structures (DDs, TableDefs, etc), plus quite a bit of source parsing.
    • gavo.rscdef.builtingrammars: The built-in grammars of DaCHS.
    • gavo.rscdef.column: Description of columns (and I/O fields).
    • gavo.rscdef.common: Common items used by resource definition objects.
    • gavo.rscdef.coverage: The coverage RD element.
    • gavo.rscdef.dddef: Definition of data.
    • gavo.rscdef.executing: The execute element and related stuff.
    • gavo.rscdef.group: VOTable-style groups for RD tables.
    • gavo.rscdef.mixins: Resource mixins.
    • gavo.rscdef.procdef: Basic handling for embedded procedures.
    • gavo.rscdef.regtest: A framework for regression tests within RDs.
    • gavo.rscdef.rmkdef: Definition of rowmakers.
    • gavo.rscdef.rmkfuncs: Functions available to rowmaker procs.
    • gavo.rscdef.rowtriggers: Framework for ignoring rows based on various conditions.
    • gavo.rscdef.scripting: Support code for attaching scripts to objects.
    • gavo.rscdef.tabledef: Description and definition of tables.
  • gavo.rscdesc: Structure definition of resource descriptors.
  • gavo.stc: Support for the IVOA Space-Time-Coordinate data model.
    • gavo.stc.bboxes: Computing bboxes for STC geometries.
    • gavo.stc.cli: A small user interface for testing STC.
    • gavo.stc.common: Definitions and shared code for STC processing.
    • gavo.stc.conform: "Conforming" of STCSpecs, i.e., bringing one to the system and units of the other.
    • gavo.stc.dm: Definition of the structure of the internal representation (the AST).
    • gavo.stc.eq: Determining equivalence for STC systems.
    • gavo.stc.geo: Coordinate systems for positions on earth.
    • gavo.stc.spherc: Spherical sky coordinates and helpers.
    • gavo.stc.sphermath: Spherical geometry and related helper functions.
    • gavo.stc.stcs: Parsing and generating STC-S
    • gavo.stc.stcsast: Transformation of STC-S CSTs to STC ASTs.
    • gavo.stc.stcsdefaults: Functions for adding defaults to STC-S concrete syntax trees.
    • gavo.stc.stcsgen: Converting ASTs to STC-S.
    • gavo.stc.stcx: Building STC-X documents, xmlstan-style.
    • gavo.stc.stcxast: Building ASTs from STC-X trees.
    • gavo.stc.stcxgen: Converting ASTs to/from STC-X.
    • gavo.stc.syslib: Arnold Rots' "library" of standard systems.
    • gavo.stc.tapstc: The subset of STC proposed by the TAP spec.
    • gavo.stc.times: Helpers for time parsing and conversion.
    • gavo.stc.units: Definition and conversion of units in STC
    • gavo.stc.utypeast: Parse utype sets into ASTs.
    • gavo.stc.utypegen: Generating a utype/value sequence for ASTs.
  • gavo.svcs: Services, cores, and support.
    • gavo.svcs.common: Common functions and classes for services and cores.
    • gavo.svcs.computedcore: Cores wrapping some external program directly, or having some python code doing things.
    • gavo.svcs.core: Cores are the standard object for computing things in the DC.
    • gavo.svcs.customcore: User-defined cores
    • gavo.svcs.customwidgets: Nevow formal custom widgets used by the DC (enumerations, table options, etc)
    • gavo.svcs.dalipars: DALI-type input parameters.
    • gavo.svcs.inputdef: Description and handling of inputs to services.
    • gavo.svcs.outputdef: Output tables and their components.
    • gavo.svcs.pql: Code to support PQL syntax (as found in various DAL protocols).
    • gavo.svcs.renderers: A manual registry of renderers.
    • gavo.svcs.runner: Methods and classes to run programs described through DataDescriptors within a twisted event loop.
    • gavo.svcs.service: Services, i.e.
    • gavo.svcs.standardcores: Some standard cores for services.
    • gavo.svcs.streaming: Streaming out large computed things using twisted and threads.
    • gavo.svcs.uploadcores: Cores to alter the DB state from the Web.
    • gavo.svcs.vanity: Parsing and maintaining URL shortcuts.
    • gavo.svcs.vizierexprs: Classes and methods to support vizier-type specifications on fields.
  • gavo.user: "User-interface"-type code.
    • gavo.user.admin: DC administration interface.
    • gavo.user.cli: The main entry point to CLI usage of GAVO code.
    • gavo.user.common: Common functionality for the DC user interface.
    • gavo.user.docgen: Generation of system docs by introspection and combination with static docs.
    • gavo.user.dropping: Dropping resources.
    • gavo.user.errhandle: Common error handling facilities for user interface components.
    • gavo.user.importing: The user interface to importing resources into the VO.
    • gavo.user.info: Commands for obtaining information about various things in the data center.
    • gavo.user.initdachs: Initial setup for the file system hierarchy.
    • gavo.user.logui: An observer doing logging of warnings, infos, errors, etc.
    • gavo.user.mkrd: Creation of resource descriptors
    • gavo.user.plainui: Observers for running interactive programs in the terminal.
    • gavo.user.rdmanipulator: Helpers for manipulating serialised RDs.
    • gavo.user.serve: A wrapper script suitable for starting the server.
    • gavo.user.show: CLI function to show various things.
    • gavo.user.upgrade: Stuff dealing with the upgrade of the database schema.
    • gavo.user.useless: Useless observers.
    • gavo.user.validation: A cli-facing module providing functionality to "validate" one or more resource descriptors.
  • gavo.utils: Miscellaneous helper modules for DACHS' python modules.
    • gavo.utils.algotricks: Some fundamental algorithms not found in the standard library.
    • gavo.utils.autonode: Autonodes are stripped-down versions of the full DaCHS structures.
    • gavo.utils.codetricks: Functions dealing with compilation and introspection of python and external code.
    • gavo.utils.excs: Global exceptions for the GAVO data center software.
    • gavo.utils.fancyconfig: A wrapper around ConfigParser that defines syntax and types within the configuration options.
    • gavo.utils.fitstools: Some utility functions to deal with FITS files.
    • gavo.utils.imgtools: Some miscellaneous helpers for making images and such.
    • gavo.utils.mathtricks: Math-related helper functions.
    • gavo.utils.misctricks: Various helpers that didn't fit into any other xTricks.
    • gavo.utils.ostricks: OS abstractions and related.
    • gavo.utils.pgexplain: Parsing Postgres query plans (somewhat).
    • gavo.utils.pgsphere: Bindings for the pgsphere libarary and psycopg2.
    • gavo.utils.plainxml: Some XML hacks.
    • gavo.utils.serializers: A framework for pluggable serialisation of (python) values.
    • gavo.utils.stanxml: A stan-like model for building namespaced XML trees.
    • gavo.utils.texttricks: Formatting, text manipulation, string constants, and such.
    • gavo.utils.typeconversions: Conversions between type systems.
  • gavo.votable: GAVO's VOTable python library.
    • gavo.votable.coding: Common code for coding and decoding VOTable data.
    • gavo.votable.common: Common definitions for the GAVO VOTable modules.
    • gavo.votable.dec_binary: Coding and decoding from binary.
    • gavo.votable.dec_binary2: BINARY2 VOTable decoding
    • gavo.votable.dec_tabledata: Coding and decoding from tabledata.
    • gavo.votable.enc_binary: Binary VOTable encoding.
    • gavo.votable.enc_binary2: BINARY2 VOTable encoding.
    • gavo.votable.enc_tabledata: Encoding to tabledata.
    • gavo.votable.model: xmlstan elements of VOTable.
    • gavo.votable.modelgroups: Legacy data model related code.
    • gavo.votable.paramval: Serialisation of python values to VOTable PARAM values.
    • gavo.votable.simple: A simplified API to single-table VOTables.
    • gavo.votable.tableparser: Parsing various forms of tabular data embedded in VOTables.
    • gavo.votable.tablewriter: Writing tabular data within VOTables.
    • gavo.votable.tapquery: An interface to querying TAP servers (i.e., a TAP client).
    • gavo.votable.votparse: Stream parsing of VOTables.
  • gavo.web: Code for talking to http clients.
    • gavo.web.adminrender: A renderer to do RD-based maintainance.
    • gavo.web.asyncrender: Renderers and helpers for asynchronous services.
    • gavo.web.caching: A simple caching system for nevow pages.
    • gavo.web.common: Common code for the nevow based interface.
    • gavo.web.constantrender: Renderer not reacting too strongly on user input.
    • gavo.web.customrender: User-defined renderers.
    • gavo.web.examplesrender: The renderer for VOSI examples, plus the docutils extensions provided for them.
    • gavo.web.formrender: The form renderer is the standard renderer for web-facing services.
    • gavo.web.grend: Basic Code for Renderers.
    • gavo.web.htmltable: A renderer for Data to HTML/stan
    • gavo.web.ifpages: Infrastructure pages.
    • gavo.web.jsonquery: Fast Web->DB->JSON machinery, for now only for the portal page.
    • gavo.web.metarender: Renderers that take services "as arguments".
    • gavo.web.oddrender: "Odd" renderers that should have been CustomRenderers all along.
    • gavo.web.productrender: Code dealing with product (i.e., fits file) delivery.
    • gavo.web.producttar: Helper functions for producing tar files from tables containing a product column.
    • gavo.web.qprenderer: A renderer that queries a single field in a service.
    • gavo.web.root: The root resource of the data center.
    • gavo.web.serviceresults: "Output drivers" for various formats, for the use of form-like renderers.
    • gavo.web.soaprender: SOAP rendering and related classes.
    • gavo.web.taprender: A renderer for TAP, both sync and async.
    • gavo.web.uploadservice: Renderers supporting upload cores.
    • gavo.web.vodal: Support for IVOA DAL and registry protocols.
    • gavo.web.vosi: VOSI renderers.
    • gavo.web.weberrors: Default error displays for the data center and error helper code.
    • gavo.web.webtests: A special renderer for testish things requring the full server to be up
    • gavo.web.wsdl: Code to expose our services via SOAP and WSDL.