def toml_headers(): filename = Path("_netlify.toml") doc = document() doc.add(comment("netlify.toml")) doc.add(comment("Generated: " + datetime.now().isoformat())) build = table() env = table().indent(2) env["YARN_VERSION"] = "1.21.0" build["publish"] = "_site/" build["command"] = "make build" build["environment"] = env doc["build"] = build headers = aot() sw = make_headers("sw.js", { "service-worker-allowed": "/", "cache-control": NO_CACHE }) headers.append(sw) manifest = make_headers("**/manifest.json", {"cache-control": NO_CACHE}) headers.append(manifest) for pattern in FOREVER_PATTERNS: headers.append(make_headers(pattern, {"cache-control": CACHE_FOREVER})) doc["headers"] = headers output = dumps(doc) print(output) sz = filename.write_text(output) print(sz)
def reorder_source_keys(data): # type: (tomlkit.toml_document.TOMLDocument) -> tomlkit.toml_document.TOMLDocument sources = [] # type: sources_type for source_key in ["source", "sources"]: sources.extend(data.get(source_key, tomlkit.aot()).value) new_source_aot = tomlkit.aot() for entry in sources: table = tomlkit.table() # type: tomlkit.items.Table source_entry = PipfileLoader.populate_source(entry.copy()) for key in ["name", "url", "verify_ssl"]: table.update({key: source_entry[key]}) new_source_aot.append(table) data["source"] = new_source_aot if data.get("sources", None): del data["sources"] return data
def add_hook(test_repo: Path, name: str, cmd: str, after_push: bool = False) -> None: """ Patch the configuration file so that we can also test hooks. """ cfg_path = test_repo / "pyproject.toml" parsed = tomlkit.loads(cfg_path.text()) if after_push: key = "after_push" else: key = "before_commit" if key not in parsed["tool"]["tbump"]: parsed["tool"]["tbump"][key] = tomlkit.aot() hook_config = tomlkit.table() hook_config.add("cmd", cmd) hook_config.add("name", name) parsed["tool"]["tbump"][key].append(hook_config) from pprint import pprint pprint(parsed) cfg_path.write_text(tomlkit.dumps(parsed)) tbump.git.run_git(test_repo, "add", ".") tbump.git.run_git(test_repo, "commit", "--message", "update hooks")
def format_lockfile( mapping: Dict[str, Candidate], fetched_dependencies: Dict[str, List[Requirement]], summary_collection: Dict[str, str], ) -> Dict: """Format lock file from a dict of resolved candidates, a mapping of dependencies and a collection of package summaries. """ packages = tomlkit.aot() file_hashes = tomlkit.table() for k, v in sorted(mapping.items()): base = tomlkit.table() base.update(v.as_lockfile_entry()) base.add("summary", summary_collection[strip_extras(k)[0]]) deps = make_array([r.as_line() for r in fetched_dependencies[k]], True) if len(deps) > 0: base.add("dependencies", deps) packages.append(base) if v.hashes: key = f"{k} {v.version}" array = tomlkit.array() array.multiline(True) for filename, hash_value in v.hashes.items(): inline = make_inline_table({"file": filename, "hash": hash_value}) array.append(inline) if array: file_hashes.add(key, array) doc = tomlkit.document() doc.add("package", packages) metadata = tomlkit.table() metadata.add("files", file_hashes) doc.add("metadata", metadata) return doc
def format_lockfile(mapping, fetched_dependencies, summary_collection): """Format lock file from a dict of resolved candidates, a mapping of dependencies and a collection of package summaries. """ packages = tomlkit.aot() metadata = tomlkit.table() for k, v in sorted(mapping.items()): base = tomlkit.table() base.update(v.as_lockfile_entry()) base.add("summary", summary_collection[strip_extras(k)[0]]) deps = tomlkit.table() for r in fetched_dependencies[k].values(): name, req = r.as_req_dict() if getattr(req, "items", None) is not None: inline = tomlkit.inline_table() inline.update(req) deps.add(name, inline) else: deps.add(name, req) if len(deps) > 0: base.add("dependencies", deps) packages.append(base) if v.hashes: key = f"{k} {v.version}" array = tomlkit.array() array.multiline(True) for filename, hash_value in v.hashes.items(): inline = tomlkit.inline_table() inline.update({"file": filename, "hash": hash_value}) array.append(inline) if array: metadata.add(key, array) doc = tomlkit.document() doc.update({"package": packages, "metadata": metadata}) return doc
def dumps(self, reqs, project: RootDependency, content=None) -> str: if content: doc = tomlkit.parse(content) else: doc = tomlkit.document() section = doc['source'] if 'source' in doc else tomlkit.aot() added_repos = {repo['name'] for repo in section} updated = False for req in reqs: if not isinstance(req.dep.repo, RepositoriesRegistry): continue for repo in req.dep.repo.repos: if repo.name in added_repos: continue # https://github.com/pypa/pipenv/issues/2231 if isinstance(repo, WarehouseLocalRepo): continue added_repos.add(repo.name) source = tomlkit.table() source['name'] = repo.name source['url'] = repo.pretty_url source['verify_ssl'] = repo.pretty_url.startswith('https://') section.append(source) updated = True if updated: doc['source'] = section if project.python: python = Pythons(abstract=True).get_by_spec(project.python) if 'requires' not in doc: doc['requires'] = tomlkit.table() doc['requires']['python_version'] = str(python.get_short_version()) for section, is_dev in [('packages', False), ('dev-packages', True)]: # create section if doesn't exist if section not in doc: doc[section] = tomlkit.table() continue # clean packages from old packages names = {req.name for req in reqs if is_dev is req.is_dev} for name in doc[section]: if name not in names: del doc[section][name] # write new packages for section, is_dev in [('packages', False), ('dev-packages', True)]: for req in reqs: if is_dev is req.is_dev: doc[section][req.raw_name] = self._format_req(req=req) return tomlkit.dumps(doc).rstrip() + '\n'
def _add_repositories(section, reqs): # get repositories urls = dict() for req in reqs: if not isinstance(req.dep.repo, RepositoriesRegistry): continue for repo in req.dep.repo.repos: if isinstance(repo, WarehouseLocalRepo): continue if urlparse(repo.pretty_url).hostname in ('pypi.org', 'pypi.python.org'): continue urls[repo.name] = repo.pretty_url # remove or update old repositories added = [] if section.get('source'): old = list(section['source']) section['source'] = tomlkit.aot() added = [] for source in old: if source['name'] in urls: if source['url'] != urls[source['name']]: source['url'] = urls[source['name']] section['source'].append(source) added.append(source['name']) sources = section['source'] else: sources = tomlkit.aot() # add new repositories for name, url in sorted(urls.items()): if name not in added: source = tomlkit.table() source['name'] = name source['url'] = url sources.append(source) section['source'] = sources
def dumps(self, reqs, project: RootDependency, content=None) -> str: doc = tomlkit.parse(content) if content else tomlkit.document() doc['package'] = [self._format_req(req=req) for req in reqs] # add extras extras = defaultdict(list) for req in reqs: if req.is_main: for extra in req.main_envs: extras[extra].append(req.name) if req.is_dev: for extra in req.dev_envs: extras[extra].append(req.name) if extras: doc['extras'] = dict(extras) # add repositories sources = tomlkit.aot() added = set() for req in reqs: if not isinstance(req.dep.repo, RepositoriesRegistry): continue for repo in req.dep.repo.repos: if repo.name in added: continue if isinstance(repo, WarehouseLocalRepo): continue if urlparse(repo.pretty_url).hostname in ('pypi.org', 'pypi.python.org'): continue added.add(repo.name) source = tomlkit.table() source['name'] = repo.name source['url'] = repo.pretty_url sources.append(source) if sources: doc['source'] = sources doc['metadata'] = { # sha256 of tool.poetry section from pyproject.toml # 'content-hash': ..., # 'platform': '*', 'python-versions': str(project.python), } doc['metadata']['hashes'] = tomlkit.table() for req in reqs: doc['metadata']['hashes'][req.name] = list(req.hashes or []) return tomlkit.dumps(doc)
def migrate_source(self): if "source" not in self._pipenv: return for s in self._pipenv["source"]: if s["name"] == "pypi": continue source = table() source.add("name", s["name"]) source.add("url", s["url"]) if "source" not in self._pyproject["tool"]["poetry"]: self._pyproject["tool"]["poetry"]["source"] = aot() self._pyproject["tool"]["poetry"]["source"].append(source)
def dumps(self, reqs, project: RootDependency, content=None) -> str: if content: doc = tomlkit.parse(content) else: doc = tomlkit.document() if 'source' not in doc: doc['source'] = tomlkit.aot() added_repos = {repo['name'] for repo in doc['source']} for req in reqs: if not isinstance(req.dep.repo, WareHouseRepo): continue if req.dep.repo.name in added_repos: continue added_repos.add(req.dep.repo.name) doc['source'].append( OrderedDict([ ('name', req.dep.repo.name), ('url', req.dep.repo.pretty_url), ('verify_ssl', True), ])) if project.python: python = Pythons(abstract=True).get_by_spec(project.python) if 'requires' not in doc: doc['requires'] = tomlkit.table() doc['requires']['python_version'] = str(python.get_short_version()) for section, is_dev in [('packages', False), ('dev-packages', True)]: # create section if doesn't exist if section not in doc: doc[section] = tomlkit.table() continue # clean packages from old packages names = {req.name for req in reqs if is_dev is req.is_dev} for name in doc[section]: if name not in names: del doc[section][name] # write new packages for section, is_dev in [('packages', False), ('dev-packages', True)]: for req in reqs: if is_dev is req.is_dev: doc[section][req.name] = self._format_req(req=req) return tomlkit.dumps(doc)
def main(source, destination): '''Run main script.''' with open(source, 'rb') as fin: data = json.load(fin) # Process the tests. document = tomlkit.document() for key, tests in data.items(): aot = tomlkit.aot() for test in tests: aot.append(create_test(test)) document.add(key, aot) # Write to file. if destination is None: print(tomlkit.dumps(document), file=sys.stdout) else: with open(destination, 'w') as fout: print(tomlkit.dumps(document), file=fout)
def dicts_to_toml_aot(cls, dicts: Sequence[Mapping[str, Any]]): """ Make a tomlkit Document consisting of an array of tables ("AOT"). Args: dicts: A sequence of dictionaries Returns: A tomlkit`AoT<https://github.com/sdispater/tomlkit/blob/master/tomlkit/items.py>`_ (i.e. ``[[array]]``) """ import tomlkit aot = tomlkit.aot() for ser in dicts: tab = tomlkit.table() aot.append(tab) for k, v in ser.items(): tab.add(k, v) tab.add(tomlkit.nl()) return aot
def format_lockfile( project: Project, mapping: dict[str, Candidate], fetched_dependencies: dict[str, list[Requirement]], ) -> dict: """Format lock file from a dict of resolved candidates, a mapping of dependencies and a collection of package summaries. """ packages = tomlkit.aot() file_hashes = tomlkit.table() for k, v in sorted(mapping.items()): base = tomlkit.table() base.update(v.as_lockfile_entry(project.root)) # type: ignore base.add("summary", v.summary or "") deps = make_array(sorted(r.as_line() for r in fetched_dependencies[k]), True) if len(deps) > 0: base.add("dependencies", deps) packages.append(base) # type: ignore if v.hashes: key = f"{strip_extras(k)[0]} {v.version}" if key in file_hashes: continue array = tomlkit.array().multiline(True) for filename, hash_value in v.hashes.items(): inline = make_inline_table({ "file": filename, "hash": hash_value }) array.append(inline) # type: ignore if array: file_hashes.add(key, array) doc = tomlkit.document() doc.add("package", packages) # type: ignore metadata = tomlkit.table() metadata.add("files", file_hashes) doc.add("metadata", metadata) # type: ignore return cast(dict, doc)
def _add_repositories(section, root: RootDependency): # get repositories urls = dict() for repo in root.warehouses: if isinstance(repo, WarehouseLocalRepo): continue urls[repo.name] = repo.pretty_url # remove or update old repositories added = [] sources = tomlkit.aot() if section.get('source'): if hasattr(section, 'item'): old_sources = section.item('source') else: old_sources = section['source'] for source in old_sources: if source['name'] in urls: if source['url'] != urls[source['name']]: source['url'] = urls[source['name']] sources.append(source) added.append(source['name']) # add new repositories for name, url in sorted(urls.items()): if name not in added: source = tomlkit.table() source['name'] = name source['url'] = url sources.append(source) section['source'] = sources # remove section if empty if not section['source']: del section['source']
def test_aot(): t = tomlkit.aot() assert isinstance(t, AoT)
def write_toml( xgm: XgmContainer, output_dirpath: str, output_tomlbase: str, progressfunc: Callable = None, ) -> None: """write an XgmContainer to a plaintext toml file and extracted contents :param xgm: XgmContainer instance :param output_dirpath: new directory to create and to unpack XGM contents to :param output_tomlbase: base filename to which to write the .XGM.toml file (will be put in output_dirpath) :param progressfunc: function to run whenever an item of the XgmContainer is about to be processed. It must accept three arguments: an int item index, an int total number of items, and an xgmitem.XgmImageItem/XgmModelItem instance """ # prepare toml dir and toml file. writing a bit early here, but if dir/file can't be # written, it's better to error before the time-consuming part instead of after tomldir = output_dirpath tomlpath = os.path.join(tomldir, output_tomlbase) os.makedirs(tomldir, exist_ok=True) num_imageitems, num_modelitems = len(xgm.imageitems), len(xgm.modelitems) with open(tomlpath, "wt", encoding="utf-8") as tomlfile: try: tomldoc = tomlkit.parse(_toml_header) tomldoc.add("ImageItem", tomlkit.aot()) for idx, imageitem in enumerate(xgm.imageitems): if progressfunc is not None: progressfunc(idx, num_imageitems, imageitem) # Extract image item to file imageitem_outname = imageitem.name16.replace(os.path.sep, "_") # sanitize with open(os.path.join(tomldir, imageitem_outname), "wb") as itemfile: itemfile.write(imageitem.filedata) # Gather & add this image item's info to toml document tomlimage = tomlkit.table() tomlimage["name16"] = imageitem.name16 if imageitem_outname != imageitem.name16: tomlimage["file-path"] = imageitem_outname # noinspection PyArgumentList tomldoc["ImageItem"].append(tomlimage) if xgm.modelitems: tomldoc.add(tomlkit.nl()) tomldoc.add("ModelItem", tomlkit.aot()) for idx, modelitem in enumerate(xgm.modelitems): if progressfunc is not None: progressfunc(idx, num_modelitems, modelitem) # Extract model item to file modelitem_outname = modelitem.name16.replace(os.path.sep, "_") # sanitize with open(os.path.join(tomldir, modelitem_outname), "wb") as itemfile: itemfile.write(modelitem.filedata) # Extract animation entry data to file animsep_outname = replaceext(modelitem_outname, ANIMSEP_EXT) with open(os.path.join(tomldir, animsep_outname), "wb") as animsepfile: animsepfile.write(modelitem.animdata) # Gather & add this model item's info to toml document tomlmodel = tomlkit.table() tomlmodel["name16"] = modelitem.name16 if modelitem_outname != modelitem.name16: tomlimage["file-path"] = modelitem_outname # noinspection PyArgumentList tomldoc["ModelItem"].append(tomlmodel) tomlfile.write(tomldoc.as_string()) except Exception: # noinspection PyBroadException try: # For debug output, try to write current tomldoc + error traceback import traceback tb = traceback.format_exc() tomlfile.write(tomldoc.as_string()) tomlfile.write( "\n\n# == ERROR ENCOUNTERED DURING WRITING ==\n#") tomlfile.write("\n#".join(tb.split("\n"))) except Exception: pass raise
def __call__(self) -> bool: path = self._global_config_path if path.exists(): doc = tomlkit.parse(path.read_text(encoding='utf8')) else: doc = tomlkit.document() creds = doc.get('auth') or tomlkit.aot() hst = self.args.hostname usr = self.args.username pwd = self.args.password # delete all credentials for hostname if not usr: new = [cred for cred in creds if cred['hostname'] != hst] diff = len(creds) - len(new) if diff == 0: self.logger.error('cannot find credentials to remove', extra=dict( hostname=hst, )) return False doc['auth'] = new path.write_text(tomlkit.dumps(doc), encoding='utf8') self.logger.info('credentials removed', extra=dict( hostname=hst, count=diff, )) return True # delete one credential if not pwd: new = [cred for cred in creds if cred['hostname'] != hst or cred['username'] != usr] diff = len(creds) - len(new) if diff == 0: self.logger.error('cannot find credentials to remove', extra=dict( hostname=hst, username=usr, )) return False doc['auth'] = new path.write_text(tomlkit.dumps(doc), encoding='utf8') self.logger.info('credentials removed', extra=dict( hostname=hst, username=usr, )) return True # update updated = False for cred in creds: if cred['hostname'] == hst and cred['username'] == usr: cred['password'] = pwd updated = True if updated: doc['auth'] = creds path.write_text(tomlkit.dumps(doc), encoding='utf8') self.logger.info('credentials updated', extra=dict( hostname=hst, username=usr, )) return True # add cred = tomlkit.table() cred['hostname'] = hst cred['username'] = usr cred['password'] = pwd creds.append(cred) doc['auth'] = creds path.write_text(tomlkit.dumps(doc), encoding='utf8') self.logger.info('credentials added', extra=dict( hostname=hst, username=usr, )) return True
def test_build_example(example): content = example("example") doc = document() doc.add(comment("This is a TOML document. Boom.")) doc.add(nl()) doc.add("title", "TOML Example") owner = table() owner.add("name", "Tom Preston-Werner") owner.add("organization", "GitHub") owner.add("bio", "GitHub Cofounder & CEO\\nLikes tater tots and beer.") owner.add("dob", datetime.datetime(1979, 5, 27, 7, 32, tzinfo=_utc)) owner["dob"].comment("First class dates? Why not?") doc.add("owner", owner) database = table() database["server"] = "192.168.1.1" database["ports"] = [8001, 8001, 8002] database["connection_max"] = 5000 database["enabled"] = True doc["database"] = database servers = table() servers.add(nl()) c = comment( "You can indent as you please. Tabs or spaces. TOML don't care." ).indent(2) c.trivia.trail = "" servers.add(c) alpha = table() servers.append("alpha", alpha) alpha.indent(2) alpha.add("ip", "10.0.0.1") alpha.add("dc", "eqdc10") beta = table() servers.append("beta", beta) beta.add("ip", "10.0.0.2") beta.add("dc", "eqdc10") beta.add("country", "中国") beta["country"].comment("This should be parsed as UTF-8") beta.indent(2) doc["servers"] = servers clients = table() doc.add("clients", clients) clients["data"] = item( [["gamma", "delta"], [1, 2]]).comment("just an update to make sure parsers support it") clients.add(nl()) clients.add(comment("Line breaks are OK when inside arrays")) clients["hosts"] = array("""[ "alpha", "omega" ]""") doc.add(nl()) doc.add(comment("Products")) products = aot() doc["products"] = products hammer = table().indent(2) hammer["name"] = "Hammer" hammer["sku"] = 738594937 nail = table().indent(2) nail["name"] = "Nail" nail["sku"] = 284758393 nail["color"] = "gray" products.append(hammer) products.append(nail) assert content == doc.as_string()
def write_toml( imccontainer, output_dirpath, output_tomlbase, progressfunc=None, ): """write an ImcContainer to a plaintext toml file and extracted .sub.imc files imccontainer: ImcContainer instance output_dirpath: new directory to create and to unpack IMC contents to output_tomlbase: base filename to which to write the .IMC.toml file (will be put in output_dirpath) progressfunc: function to run whenever a subsong is about to be extracted from the ImcContainer. It must accept three arguments: an int subsong index, an int total number of subsongs, and an imccontainer.ContainerSubsong instance """ # for zero-padding the number in the filename of each extracted subsong, 03 vs 003 if imccontainer.num_subsongs <= 100: ssidx_width = 2 else: ssidx_width = len(str(imccontainer.num_subsongs - 1)) # prepare toml dir and toml file. writing a bit early here, but if dir/file can't be # written, it's better to error before the time-consuming part instead of after tomldir = output_dirpath tomlpath = os.path.join(tomldir, output_tomlbase) os.makedirs(tomldir, exist_ok=True) with open(tomlpath, "wt", encoding="utf-8") as tomlfile: try: tomldoc = tomlkit.parse(_toml_header) tomldoc.add("Subsong", tomlkit.aot()) for ssidx, csubsong in enumerate(imccontainer.csubsongs): if progressfunc is not None: progressfunc(ssidx, imccontainer.num_subsongs, csubsong) # Extract subsong to file ss_basefilename = f"{ssidx:0{ssidx_width}}.{csubsong.name}{SUBIMC_EXT}" # sanitize dir separators out of filename so it doesn't screw up ss_basefilename = ss_basefilename.replace(os.path.sep, "_") with open(os.path.join(tomldir, ss_basefilename), "wb") as subsongfile: subsongfile.write(csubsong.get_imcdata()) # Gather & add this subsong's info to toml document tomlsubsong = tomlkit.table() tomlsubsong["name"] = csubsong.name tomlsubsong["loadmode"] = csubsong.loadmode tomlsubsong["basefile"] = ss_basefilename channel_nums = "".join( str(x) for x in range(1, csubsong.num_channels + 1)) comment = (f'channels-{channel_nums}-to-{channel_nums} = "' f"replacement-audio{SUBSONG_FORMATS['wav']}" '"') tomlsubsong.add(tomlkit.comment(comment)) # Gather & add this subsong's diff-patch-info to toml document, # omitting anything with a None value tomldiffpinfo = tomlkit.table().indent(4) if csubsong.rawname is not None: # bytes to ints tomldiffpinfo["rawname"] = [x for x in csubsong.rawname] if not (csubsong.unk1, csubsong.unk2) == (None, None): unk1 = 0 if csubsong.unk1 is None else csubsong.unk1 unk2 = 0 if csubsong.unk2 is None else csubsong.unk2 tomldiffpinfo["unk"] = [unk1, unk2] # saving original block layout if csubsong.original_block_layout is not None: ofbp, obpc = csubsong.original_block_layout # convert from possibly a tomlkit Integer (which retains indent) to # a plain ol' int to prevent indent problems when rewritten to toml ofbp, obpc = int(ofbp), int(obpc) if ofbp is not None: tomldiffpinfo["frames-per-block"] = ofbp if obpc is not None: tomldiffpinfo["blocks-per-channel"] = obpc if tomldiffpinfo: # if tomldiffpinfo is empty, we won't bother tomlsubsong.add("diff-patch-info", tomldiffpinfo) # noinspection PyArgumentList tomldoc["Subsong"].append(tomlsubsong) except Exception: # noinspection PyBroadException try: # For debug output, try to write current tomldoc + error traceback import traceback tb = traceback.format_exc() tomlfile.write(tomldoc.as_string()) tomlfile.write( "\n\n# == ERROR ENCOUNTERED DURING WRITING ==\n#") tomlfile.write("\n#".join(tb.split("\n"))) except Exception: pass raise tomlfile.write(tomldoc.as_string())
def run(): # The toml document doc = document() # General settings doc['general'] = table() doc['general']['IgnoreFailureOnStart'] = False # DISCORD print('Let\'s setup Discord...') doc['discord'] = table() doc['discord'].comment('Discord server connection settings') doc['discord']['rcos'] = table() doc['discord']['rcos']['Token'] = get_from_env_or_input( 'DISCORD_BOT_TOKEN', 'Bot Token: ') doc['discord']['rcos']['Token'].comment( 'SECRET bot token found on https://discord.com/developers') doc['discord']['rcos']['Server'] = get_from_env_or_input( 'RCOS_SERVER_ID', 'Server: ') doc['discord']['rcos']['Server'].comment( 'The ID of the Discord server. Can be found in URL when on Discord or if Developer Mode is turned on and right-clicking the server icon.' ) doc['discord']['rcos']['RemoteNickFormat'] = get_from_env_or_input( 'MATTERBRIDGE_DISCORD_PREFIX', 'Message prefix: ', default=DEFAULT_REMOTE_NICKNAME_FORMAT) doc['discord']['rcos']['RemoteNickFormat'].comment( 'The prefix to apply to messages.') # MATTERMOST print('\n\nNow Mattermost...') doc['mattermost'] = table() doc['mattermost'].comment('Mattermost server connection settings') doc['mattermost']['rcos'] = table() doc['mattermost']['rcos']['Server'] = 'chat.rcos.io:443' doc['mattermost']['rcos']['Server'].comment( 'URL of the Mattermost server with no http:// or https:// prepended') doc['mattermost']['rcos']['Team'] = 'rcos' doc['mattermost']['rcos']['Team'].comment( 'The "team", found as the first part of URL when on Mattermost server') doc['mattermost']['rcos']['Login'] = get_from_env_or_input( 'MATTERMOST_USERNAME', 'Username: '******'mattermost']['rcos']['Login'].comment( 'Mattermost needs a user account to send/receive messages. This is the account username.' ) doc['mattermost']['rcos']['Password'] = get_from_env_or_input( 'MATTERMOST_PASSWORD', 'Password: '******'mattermost']['rcos']['Password'].comment( 'The password of the Mattermost account to use.') doc['mattermost']['rcos']['RemoteNickFormat'] = get_from_env_or_input( 'MATTERBRIDGE_MATTERMOST_PREFIX', 'Message prefix: ', default=DEFAULT_REMOTE_NICKNAME_FORMAT) doc['mattermost']['rcos']['RemoteNickFormat'].comment( 'The prefix to apply to messages.') # The channels to pair # (Discord channel, Mattermost channel) channel_pairs = [] print( "Enter the channels you want to pair on each line and enter an empty line to finish.\nDiscord,Mattermost" ) line = input() while len(line) > 0: channel_pairs.append(line.split(",")) line = input() gateways = aot() # Create the gateways in the document for pair in enumerate(channel_pairs): gateway = table() gateway['name'] = f'gateway-{pair[1]}' gateway['enable'] = True # inout means that messages are sent/received both ways gateway['inout'] = aot() gateway_discord = table() gateway_discord['account'] = 'discord.rcos' gateway_discord['channel'] = pair[0] gateway['inout'].append(gateway_discord) gateway_mattermost = table() gateway_mattermost['account'] = 'mattermost.rcos' gateway_mattermost['channel'] = pair[1] gateway['inout'].append(gateway_mattermost) gateways.append(gateway) doc.add('gateway', gateways) # Write the output to a file with open('matterbridge.toml', 'w') as outfile: outfile.write(dumps(doc)) print( 'Wrote output to matterbridge.toml. Now place it where Matterbridge wants it!' )
def dumps(self, reqs, project: RootDependency, content=None) -> str: if content: doc = tomlkit.parse(content) else: doc = tomlkit.document() # repositories section = doc['source'] if 'source' in doc else tomlkit.aot() added_repos = {repo['name'] for repo in section} updated = False for req in reqs: if not isinstance(req.dep.repo, WarehouseBaseRepo): continue for repo in req.dep.repo.repos: if repo.from_config: continue if repo.name in added_repos: continue # https://github.com/pypa/pipenv/issues/2231 if isinstance(repo, WarehouseLocalRepo): continue added_repos.add(repo.name) source = tomlkit.table() source['name'] = repo.name source['url'] = repo.pretty_url source['verify_ssl'] = repo.pretty_url.startswith('https://') section.append(source) updated = True # pipenv doesn't work without explicit repo if not added_repos: source = tomlkit.table() source['name'] = 'pypi' source['url'] = 'https://pypi.org/simple/' source['verify_ssl'] = True section.append(source) updated = True if updated: doc['source'] = section # python version if project.python: python = Pythons(abstract=True).get_by_spec(project.python) if 'requires' not in doc: doc['requires'] = tomlkit.table() doc['requires']['python_version'] = str(python.get_short_version()) # dependencies names_mapping = dict() for section, is_dev in [('packages', False), ('dev-packages', True)]: # create section if doesn't exist if section not in doc: doc[section] = tomlkit.table() continue # clean file from outdated dependencies names = {req.name for req in reqs if is_dev is req.is_dev} for name in dict(doc[section]): normalized_name = canonicalize_name(name) names_mapping[normalized_name] = name if normalized_name not in names: del doc[section][name] # write new packages for section, is_dev in [('packages', False), ('dev-packages', True)]: for req in reqs: if is_dev is not req.is_dev: continue raw_name = names_mapping.get(req.name, req.raw_name) old_spec = doc[section].get(raw_name) # do not overwrite dep if nothing is changed if old_spec: old_dep = self._make_deps( root=RootDependency(), name=raw_name, content=old_spec, )[0] if req.same_dep(old_dep): continue # overwrite doc[section][raw_name] = self._format_req(req=req) return tomlkit.dumps(doc).rstrip() + '\n'