types1585%`python.module`
fault.project

Factored Projects data structures and types.

FactorType

Annotation signature for factor data produced by project protocols.

FactorType = tuple[
	tuple[FactorPath, Reference], # Project relative path and type.
	tuple[
		Set[Reference], # Requirements
		Iterable[tuple[Reference, Path]], # Format References and Sources
	],
]

Mapping
import

Iterable
import

Set
import

dataclass0
import

tools0
import

Segment0
import

Path0
import

ignored0
data

ignored = {
	'__pycache__',
	'__f-int__',
	'.f-int',
	'.git',
	'.svn',
	'.hg',
	'.darcs',
	'.pijul',
}

@tools.struct()

Variants0
class

object

Factor image variant specification. A triple of contrived identifiers that represent a classification.

Variants Properties

system

Identifier of the runtime environment; normally, an operating system name. Often, derived from uname.

architecture

Identifier for the instruction set or format. Often, derived from uname.

form

Identifier for the specialization of the image.

Defaults to 'executable'; the most likely intent of an image.

This is has no semantic relation to factor types; it is provided to allow parallel storage of data that serves a purpose other than supporting the execution of a project's functionality.

Variants form0
data
`str`

form:(str) = 'executable'

Variants repr20%
method

__repr__(self)

Variants str10%
method

__str__(self)

Variants get150%
method
`str`

get(self, key)

Variants reform0
method

reform(self, rform)

Reconstruct the instance with the given rform as the new form value.

Format0
class

object

Source format structure holding the language and dialect.

Format dialect0
data
`str`

dialect:(str) = None
	@classmethod

Format from_string0
classmethod

from_string()

Split the format identifier by the first . in string. Creates an instance using the first field as the language and second as the dialect. If there is no . or the dialect is an empty string, the dialect will be None,

FactorPath0
class

Segment

A fault.route.types.Segment identifying a factor.

The path is always relative; usually relative to either a product or project. Identifiers in the path exclude any filename extensions.

FactorPath str0
method

__str__(self)

FactorPath repr0
method

__repr__(self)

FactorPath matmul0
method

__matmul__(self, fpath)

Relative and absolute constructor.

factor0
data

factor = FactorPath(None, ())

@dataclass

FactorContextPaths0
class

object

File System Information regarding the context of a Factor.

This data structure is used to hold the set of directories related to an Archived Factor.

FactorContextPaths Properties

root: The route containing either the project or the context enclosure. Also known as the Product Directory.
context: The context project relevant to project. None if the project is not managed within a Project Context.
project: The route identifying the project.

FactorContextPaths root0
data
`Path`

root: (Path) = None

FactorContextPaths context0
data
`FactorPath`

context: (FactorPath) = None

FactorContextPaths project0
data
`Path`

project: (Path) = None
	@property

FactorContextPaths enclosure233%
property
`bool`

Whether the original subject was referring to an enclosure.

FactorContextPaths select40%
method

select(self, factor)

FactorContextPaths factor20%
method

factor(self)

Construct a project factor path.

Information0
class

object

Project information structure usually extracted from project.txt files.

Information Properties

identifier: A hyperlink or literal attempting to provide a unique string that can be used to identify the project.
name: The canonical local name for the project. Often, consistent with the directory or file containing the project's factors.
authority: An arbitrary string intended to identify the entity that controls the project.
contact: A string that identifies the appropriate means of contacting the authority regarding the project.

Information identifier0
data
`str`

identifier: (str) = None

Information name0
data
`str`

name: (str) = None

Information authority0
data
`str`

authority: (str) = None

Information contact0
data
`str`

	contact: (str) = None

@dataclass

Extensions0
class

object

Project information extensions.

Extensions Properties

icon: A hyperlink identifying an image that represents or symbolizes the project.
synopsis: A brief, single sentence, description of the project.

Extensions icon0
data
`str`

icon: (str) = None

Extensions synopsis0
data
`str`

	synopsis: (str) = None

@tools.struct()

Reference0
class

object

A position independent reference to a required factor and the interpretation parameters needed to properly form the relationship for integration.

project and factor are the only required fields.

Reference Properties

project

The identifier of the project that contains the required factor.

factor

The project relative path to the required factor. If empty, the reference is identifying the entire project.

method

The type of connection that is expected to be formed between the requirement and the target factor being integrated.

isolation

The specifier of a format, variant, or factor type.

For type methods, this is usually a reference to a language identifier. For control, it can be the specification of a feature's variant.

When referring to normal requirements, this is always the factor type that should be used when integration is performed.

format

In the case of type references, format provides access to a structured form of isolation: a Format instance.

Reference method0
data
`str`

method: (str) = None

Reference isolation0
data
`str`

isolation: (str) = None

Reference isolate0
method

isolate(self, isolation)

Reconstruct the reference replacing its isolation field the given isolation.

If isolation is already set, return self.

Reference str175%
method

__str__(self)

Reference format0
property

Construct the Format instance representing the isolation.

Format instances are cached and repeat reads across references with the same isolation should normally return the same object.

Reference from_ri0
classmethod

from_ri(Class, method, ri)

Create a reference from a resource indicator. Splits on the fragment and the final path segment.

FactorIsolationProtocol0
class

object

A project factor protocol.

FactorIsolationProtocol init0
method

__init__(self, parameters)

FactorIsolationProtocol information150%
method
`Information`

information(self, route)

FactorIsolationProtocol iterfactors150%
method
`Iterable[FactorType]`

iterfactors(self, route)

Protocol0
data

Protocol = FactorIsolationProtocol

ProtocolViolation0
class

Exception

The route was identified as not conforming to the protocol.

fpc0
function
`FactorPath`

fpc(context, factorpath, root)

FactorPath instance cache for relative and absolute paths constructed from strings.

When factorpath has leading periods, ., the number of periods will select the ancestor of context to start the resulting FactorPath from.

fpc Parameters

context: FactorPath
FactorPath
The relative position factorpath is to be interpreted from when leading periods are present.
factorpath: str
str
The string that is being interpreted to become a FactorPath instance.
root: The absolute position that factorpath will extend given that it is not relative.

types1585%python.modulefault.project

FactorType

Mappingimport

Iterableimport

Setimport

dataclass0import

tools0import

Segment0import

Path0import

ignored0data

Variants0class

VariantsProperties

Variantsform0datastr

Variants__repr__20%method

Variants__str__10%method

Variantsget150%methodstr

Variantsreform0method

Format0class

Formatdialect0datastr

Formatfrom_string0classmethod

FactorPath0class

FactorPath__str__0method

FactorPath__repr__0method

FactorPath__matmul__0method

factor0data

FactorContextPaths0class

FactorContextPathsProperties

FactorContextPathsroot0dataPath

FactorContextPathscontext0dataFactorPath

FactorContextPathsproject0dataPath

FactorContextPathsenclosure233%propertybool

FactorContextPathsselect40%method

FactorContextPathsfactor20%method

Information0class

InformationProperties

Informationidentifier0datastr

Informationname0datastr

Informationauthority0datastr

Informationcontact0datastr

Extensions0class

ExtensionsProperties

Extensionsicon0datastr

Extensionssynopsis0datastr

Reference0class

ReferenceProperties

Referencemethod0datastr

Referenceisolation0datastr

Referenceisolate0method

Reference__str__175%method

Referenceformat0property

Referencefrom_ri0classmethod

FactorIsolationProtocol0class

FactorIsolationProtocol__init__0method

FactorIsolationProtocolinformation150%methodInformation

FactorIsolationProtocoliterfactors150%methodIterable[FactorType]

Protocol0data

ProtocolViolation0class

fpc0functionFactorPath

fpcParameters

types1585%`python.module`
fault.project

Mapping
import

Iterable
import

Set
import

dataclass0
import

tools0
import

Segment0
import

Path0
import

ignored0
data

Variants0
class

Variants Properties

Variants form0
data
`str`

Variants repr20%
method

Variants str10%
method

Variants get150%
method
`str`

Variants reform0
method

Format0
class

Format dialect0
data
`str`

Format from_string0
classmethod

FactorPath0
class

FactorPath str0
method

FactorPath repr0
method

FactorPath matmul0
method

factor0
data

FactorContextPaths0
class

FactorContextPaths Properties

FactorContextPaths root0
data
`Path`

FactorContextPaths context0
data
`FactorPath`

FactorContextPaths project0
data
`Path`

FactorContextPaths enclosure233%
property
`bool`

FactorContextPaths select40%
method

FactorContextPaths factor20%
method

Information0
class

Information Properties

Information identifier0
data
`str`

Information name0
data
`str`

Information authority0
data
`str`

Information contact0
data
`str`

Extensions0
class

Extensions Properties

Extensions icon0
data
`str`

Extensions synopsis0
data
`str`

Reference0
class

Reference Properties

Reference method0
data
`str`

Reference isolation0
data
`str`

Reference isolate0
method

Reference str175%
method

Reference format0
property

Reference from_ri0
classmethod

FactorIsolationProtocol0
class

FactorIsolationProtocol init0
method

FactorIsolationProtocol information150%
method
`Information`

FactorIsolationProtocol iterfactors150%
method
`Iterable[FactorType]`

Protocol0
data

ProtocolViolation0
class

fpc0
function
`FactorPath`

fpc Parameters