🐞 Lowest version of FL Studio with Unicode (UTF16) strings

PyFLP

PyFLP is an unofficial parser for FL Studio project and preset files written in Python.

CI
PyPI
Activity
QA
Other

From a very general point-of-view, this is the state of what is currently implemented. Click on a link to go to the documentation for that feature.

Group	Feature	Issues
Arrangements	🎼 Playlist

	🎞️ Tracks
Channel Rack	📈 Automations
	🎹 Instruments
	📚 Layer
	📁 Sampler
Mixer	🎚️ Inserts
Mixer	🎰 Effect slots
🎶 Patterns	🎛 Controllers
	🎵 Notes

🚩 Timemarkers
Plugins	Native - 8 effects, 1 synth
Plugins	VST 2/3
Project - Settings and song metadata

⏬ Installation

CPython 3.8+ / PyPy 3.8+ required.

python -m pip install -U pyflp

▶ Usage

Load a project file:

import pyflp
project = pyflp.parse("/path/to/parse.flp")

If you get any sort of errors or warnings while doing this, please open an issue.

Save the project:

pyflp.save(project, "/path/to/save.flp")

It is advised to do a backup of your projects before doing any changes. It is also recommended to open the modified project in FL Studio to ensure that it works as intended.

Check the reference for a complete list of useable features.

🙏 Acknowledgements

Monad.FLParser: https://github.com/monadgroup/FLParser
FLPEdit (repo deleted by author)

✨ Contributors

Thanks goes to these wonderful people:

_nickberry17
💻

_zacanger
🐛 📖

_Tim
📖 💻 🚧

This project follows the all-contributors specification. Contributions of any kind are welcome!

Please see the contributor's guide for more information about contributing.

📧 Contact

You can contact me either via issues and discussions or through email via demberto(at)proton(dot)me.

© License

The code in this project has been licensed under the GNU Public License v3.

	if id == ProjectID.FLVersion:
	if int(value.decode("ascii").split(".")[0]) >= 12:
	str_type = UnicodeEvent
	else:
	str_type = AsciiEvent

	class U16TupleEvent(DWordEventBase[Tuple[int, int]]):
	"""An event used for storing a two-tuple of 2 byte unsigned integers."""

	@property
	def value(self) -> tuple[int, int]:
	return UInt.unpack(self._raw)

	@value.setter
	def value(self, value: tuple[int, int]):
	self._raw = UInt.pack(*value)

	@property
	def tracks(self) -> Iterator[Track]:
	count = 0
	event = None
	max_idx = 499 if dataclasses.astuple(self._kw["version"]) >= (12, 9, 1) else 198

	if ArrangementID.Playlist in self._events:
	event = cast(PlaylistEvent, self._events[ArrangementID.Playlist][0])

	for events in self._collect_events(TrackID):
	items: list[_PlaylistItemStruct] = []
	if event is not None:
	for item in event.items:
	idx = item["track_index"]
	if max_idx - idx == count:
	items.append(cast(_PlaylistItemStruct, item))
	yield Track(*events, items=items)

	# TODO Verify ArrangementsID.Current is the end
	# FL changed event ordering a lot, the latest being the most easiest to
	# parse; it contains ArrangementID.New event followed by TimeMarker events
	# followed by 500 TrackID events. TimeMarkers occured before new arrangement
	# event in initial versions of FL20, making them harder to group.
	def __iter__(self) -> Iterator[Arrangement]:
	first = True
	events: list[AnyEvent] = []

	def make_arr():
	return Arrangement(*events, version=self._kw["version"])

	for event in self._events_tuple:
	if event.id == ArrangementID.New:
	if not first:
	yield make_arr()
	events = []
	first = not first
	elif event.id == ArrangementsID.Current:
	return make_arr() # last arrangement

	for enum_ in (ArrangementID, TimeMarkerID, TrackID):
	if event.id in enum_:
	events.append(event)
	break

	@pytest.fixture
	def load_channel(get_model: ModelFixture):
	def wrapper(preset: str, type: type[Channel] = Channel):
	return get_model(f"channels/{preset}", type)

	return wrapper


	@pytest.fixture
	def load_instrument(load_channel: ModelFixture):
	def wrapper(preset: str):
	return load_channel(preset, Instrument)

	return wrapper


	@pytest.fixture
	def load_layer(load_channel: Any):
	def wrapper(preset: str):
	return load_channel(preset, Layer)

	return wrapper


	@pytest.fixture
	def load_sampler(load_channel: Any):
	def wrapper(preset: str):
	return load_channel(preset, Sampler)

	return wrapper

	ChannelFixture = Callable[[str], Channel]
	InstrumentFixture = Callable[[str], Instrument]
	LayerFixture = Callable[[str], Layer]
	SamplerFixture = Callable[[str], Sampler]

	# TODO Return note names instead of integers
	key = StructProp[int]()
	"""0-131 for C0-B10. Can hold stamped chords and scales also."""

	items: _InsertEQBandKW = {}
	for param in instance._kw["params"]:
	id = param["id"]
	if id == self._ids.freq:
	items["freq"] = param
	elif id == self._ids.gain:
	items["gain"] = param
	elif id == self._ids.reso:
	items["reso"] = param
	return InsertEQBand(kw=items)

	class Content(MultiEventModel, ModelReprMixin):
	"""Used by :class:`Sampler`."""

	# declick_mode: enum
	keep_on_disk = FlagProp(_SamplerFlags.KeepOnDisk, ChannelID.SamplerFlags)
	load_regions = FlagProp(_SamplerFlags.LoadRegions, ChannelID.SamplerFlags)
	load_slices = FlagProp(_SamplerFlags.LoadSliceMarkers, ChannelID.SamplerFlags)
	resample = FlagProp(_SamplerFlags.Resample, ChannelID.SamplerFlags)

	if ArrangementID.Playlist in self._events:
	pl_event = cast(PlaylistEvent, self._events[ArrangementID.Playlist][0])

	for events in self._collect_events(TrackID):
	items: list[_PlaylistItemStruct] = []
	if pl_event is not None:
	for item in pl_event.items:
	idx = item["track_index"]
	if max_idx - idx == count:
	items.append(cast(_PlaylistItemStruct, item))
	yield Track(*events, items=items)

	class Track(MultiEventModel, Iterable[PlaylistItemBase], SupportsIndex):
	"""Represents a track in an arrangement on which playlist items are arranged.

	![](https://bit.ly/3de6R8y)
	"""

	def __init__(self, events: AnyEvent, *kw: Unpack[_TrackKW]):
	super().__init__(events, *kw)

	items = KWProp[List[PlaylistItemBase]]()
	"""Playlist items present on the track."""

	height = StructProp[float](id=TrackID.Data)
	"""Track height in FL's interface. Linear.

	\| Type \| Value \| Percentage \|
	\|---------\|-------\|------------\|
	\| Min \| 0.0 \| 0% \|
	\| Max \| 18.4 \| 1840% \|
	\| Default \| 1.0 \| 100% \|
	"""

	# ChannelIID, _161, _162, Looped, Length occur when pattern is looped.
	# ChannelIID and _161 occur for every channel in order.
	# ! Looping a pattern puts timemarkers in it. The same TimeMarkerID events are
	# !used, which means I need to refactor it out from pyflp.arrangement.

	ChannelIID = (DWORD + 32, U32Event) # TODO (FL v20.1b1+)
	_161 = (DWORD + 33, I32Event) # TODO -3 if channel is looped else 0 (FL v20.1b1+)
	_162 = (DWORD + 34, U32Event) # TODO Appears when pattern is looped, default: 2

	"track_index": "i", # 16
	"_u2": 2, # 18

	"height": "f", # 17
	"locked_height": "f", # 21

	class ChannelType(enum.IntEnum): # cuz Type would be a super generic name
	"""An internal marker used to indicate the type of a channel."""

	Sampler = 0
	"""Used exclusively for the inbuilt Sampler."""

	Native = 2
	"""Used by audio clips and other native FL Studio synths."""

	Layer = 3 # 3.4.0+
	Instrument = 4
	Automation = 5 # 5.0+

	def __iter__(self): # pylint: disable=too-complex
	ch_dict: dict[int, Channel] = {}
	events: DefaultDict[int, list[AnyEvent]] = collections.defaultdict(list)
	cur_ch_events = []
	for event in self._events_tuple:
	if event.id == ChannelID.New:
	cur_ch_events = events[event.value]

	if event.id not in RackID:
	cur_ch_events.append(event)

	for iid, ch_events in events.items():
	ct = None
	for event in ch_events:
	if event.id == ChannelID.Type:
	if event.value == ChannelType.Automation:
	ct = Automation
	elif event.value == ChannelType.Instrument:
	ct = Instrument
	elif event.value == ChannelType.Layer:
	ct = Layer
	elif event.value == ChannelType.Sampler:
	ct = Sampler
	else:
	ct = Channel

	if ct is not None:
	cur_ch = ch_dict[iid] = ct(*ch_events, channels=ch_dict)
	yield cur_ch

	def dock(self) -> InsertDock \| None:
	"""The position (left, middle or right) where insert is docked in mixer.

	![](https://bit.ly/3eLum9D)
	"""
	events = self._events.get(InsertID.Flags)
	if events is not None:
	event = cast(InsertFlagsEvent, events[0])
	if _InsertFlags.DockMiddle in event["flags"]:
	return InsertDock.Middle
	if _InsertFlags.DockRight in event["flags"]:
	return InsertDock.Right
	return InsertDock.Left

	class _EnvelopeLFOStruct(StructBase): # 2.5.0+
	PROPS = {
	"flags": "i", # 4
	"envelope.enabled": "i", # 8
	"envelope.predelay": "i", # 12
	"envelope.attack": "i", # 16
	"envelope.hold": "i", # 20
	"envelope.decay": "i", # 24
	"envelope.sustain": "i", # 28
	"envelope.release": "i", # 32
	"_u20": 20, # 52
	"lfo.shape": "i", # 56
	"envelope.attack_tension": "i", # 60
	"envelope.sustain_tension": "i", # 64
	"envelope.release_tension": "i", # 68
	}

	key = StructProp[int]() # TODO Separate property and chord/scale detection
	"""0-131 for C0-B10. Can hold stamped chords and scales also."""

	height = EventProp[int](ArrangementsID.WindowHeight)
	"""Window height / track width used by the interface."""

	class Playback(MultiEventModel, ModelReprMixin):
	"""Used by :class:`Sampler`.

	![](https://bit.ly/3xjSypY)
	"""

	ping_pong_loop = EventProp[bool](ChannelID.PingPongLoop)
	# start_offset: int
	use_loop_points = FlagProp(_SamplerFlags.UsesLoopPoints, ChannelID.SamplerFlags)

	def transform_image_links(app, what, name, obj, options, lines):
	"""Convert Bit.ly markdown image links to local reStructuredText ones."""
	for idx, line in enumerate(lines):
	match = BITLY_LINK.fullmatch(line)
	if match is not None:
	url = urlopen(match[1]).geturl()
	lines[idx] = f".. image:: {url.replace(GHUC_PREFIX, '', 1)}"

	# TODO Add link to GIF from docs once Bitly quota is available again.
	enabled = StructProp[bool](id=TrackID.Data)

	# TODO Add link to GIF from docs once Bitly quota is available again.
	locked = StructProp[bool](id=TrackID.Data)
	"""Whether the tracked is in a locked state."""

	# TODO Add link to GIF from docs once Bitly quota is available again.
	enabled = EventProp[bool](ChannelID.IsEnabled)

	def __init__(self, stream: BytesIOEx):
	self._props: dict[str, Any] = dict.fromkeys(type(self).PROPS)
	self._stream = stream
	self._stream_len = len(stream.getvalue())

	for key, type_or_size in type(self).PROPS.items():
	if isinstance(type_or_size, int):
	self._props[key] = self._stream.read(type_or_size)
	else:
	self._props[key] = getattr(self._stream, f"read_{type_or_size}")()

demberto / pyflp Goto Github PK

pyflp's Introduction

PyFLP

⏬ Installation

▶ Usage

🙏 Acknowledgements

✨ Contributors

📧 Contact

© License

pyflp's People

Contributors

Stargazers

Watchers

Forkers

pyflp's Issues

TrackStruct

Track

TrackStruct:

Track:

Why?

Tests

Observations

Solutions

Describe the issue

PyFLP version

What code caused this issue?

Screenshots, Additional info

Code of Conduct

😎 What I already know

⏰ What's with time signatures?

👀 Where to look for?

Generators

Effects

Notes for implementers

Solution 1; Change StructBase to encode and decode colour.Color directly into StructEvent._props

Solution 2: Add a ColorProp to pyflp._base, specifically for colours encoded in variable sized events

Describe the issue

PyFLP version

What code caused this issue?

Screenshots, Additional info

Code of Conduct

IterProp is for properties having multiple events

The problem

Recommend Projects

Recommend Topics

Recommend Org

Jobs

`TrackStruct`

`Track`

`TrackStruct`:

`Track`:

Solution 1; Change `StructBase` to encode and decode `colour.Color` directly into `StructEvent._props`

Solution 2: Add a `ColorProp` to `pyflp._base`, specifically for colours encoded in variable sized events

`IterProp` is for properties having multiple events

	def __setitem__(self, key: str, value: Any):
	if key not in type(self).PROPS:
	raise KeyError(key)

	self._stream.seek(type(self).OFFSETS[key])
	type_or_size = type(self).PROPS[key]
	if isinstance(type_or_size, int):
	self._stream.write(value)
	else:
	getattr(self._stream, f"write_{type_or_size}")(value)

	if len(self._stream.getvalue()) > self._stream_len and self.TRUNCATE:
	raise PropertyCannotBeSet
	self._props[key] = value

	envelopes = IterProp(ChannelID.EnvelopeLFO, Envelope)
	"""One each for Volume, Panning, Mod X, Mod Y and Pitch :class:`Envelope`."""

	lfos = IterProp(ChannelID.EnvelopeLFO, LFO)
	"""One each for Volume, Panning, Mod X, Mod Y and Pitch :class:`LFO`."""