Saravanan666/pypi-org huggingface dataset:
Package: tagfile
Search, index and tag your files and find duplicates.The goal of tagfile is to manage and organize documents, downloads,
music, pictures and videos in a way that is not tied to any file browser
program, filesystem or operating system.The metadata that tagfile creates and uses to keep track of these
files should be portable for use in multiple computer systems and be
independent from any persistent mount points, filepaths or filenames.Featuresindex files with their checksumsfind duplicate filesscan all files in a directory recursivelyignore files according to rules in user configFeatures to be implemented in later versions:remove duplicate files in the same directoryremove duplicate files interactively across directoriesadd user defined tags to files (using checksums, independent from filenames)Ideas that may or may not be implemented in later versions:ability to filter files using tags to create listings to use with
other programsability to use tags to create directory structures of symlinked contentQuick ManualOpen a terminal and cd to a directory to be scanned for files:$cd~/Music$tagfilescanNow, you can see stats, search for files by string and find duplicate
files using the following commands:$tagfilestats$tagfilefindradiohead$tagfilesameYou can add directories without cd’ing to it first with the add command:$tagfileadd~/VideosInstalling tagfileTagfile is a command-line end-user application written in Python that
is dependant on packages from PyPI. You can install it using pip. But
using pipx (https://pypa.github.io/pipx/) is recommended because it
avoids dependency problems and/or clashes with python packages from your
system’s package manager in the future.Install tagfile:$pipxinstalltagfileTo build and install from source you can use:$makeinstallThis will auto-install flit (build tool) and pipx if not found.To upgrade or uninstall tagfile in the future you can use:$pipxupgradetagfile$pipxuninstalltagfileStatusCurrent version:v0.1.0Tagfile has been written in a short time and used by me sporadically for
8 years after that. All code was contained in a single file script in~/bin, available from Github only.Starting in March 2023 I’ve decided to properly release it to PyPI and
flesh out the current project structure, command interface and database
handling before working on new features so it may live up to its name.
Since at this moment in time, you cannot tag your files yet :)Tagfile adheres toSemantic Versioning. Until
a stable version 1.0.0 is ready, the API, CLI and config settings are
subject to change from 0.x version to 0.x version, likely without
offering migrations.Prerequisites:Python 3.7 or laterDependencies (automatically installed with pipx / pip):Peewee ORM (https://peewee.readthedocs.org/en/latest/)PyYAML (https://pyyaml.org/)ansicolors (https://pypi.python.org/pypi/ansicolors/)pycommand (https://babab.github.io/pycommand/)Software licenseCopyright (c) 2015-2023 Benjamin Althues <benjamin at babab . nl>tagfile is open source software, licensed under a BSD-3-Clause license.
See theLICENSEfile for the full license text.
Package: tagfiles
tagfilesA tagging interface for multiple audio formats and metadata containers.The supported audio codecs and containers are:FLAC in FLAC containerMP3 in MP3 containerAAC in MP4 containerVorbis in Ogg containerOpus in Ogg containerTag mappings are derived fromhttps://picard.musicbrainz.org/docs/mappings/.Usage>>>fromtagfilesimportTagFile,ArtistRoles>>>frompprintimportpprint>>>>>>tf=TagFile('/home/azuline/02. No Captain.m4a')>>>print(tf.title)NoCaptain>>>pprint(tf.artist){<ArtistRoles.MAIN:1>:['Lane 8'],<ArtistRoles.FEATURE:2>:['Poliça'],<ArtistRoles.REMIXER:3>:[],<ArtistRoles.PRODUCER:4>:[],<ArtistRoles.COMPOSER:5>:[''],<ArtistRoles.CONDUCTOR:6>:[],<ArtistRoles.DJMIXER:7>:[]}>>>print(tf.artist[ArtistRoles.MAIN])['Lane 8']>>>print(tf.date.year)2015>>>print(tf.date.date)2015-01-19>>>>>>tf.date='2018-01-19'# Fixing the date!>>>print(tf.date.date)2018-01-19>>>print(tf.date.year)2018>>>tf.save()>>>>>>tf=TagFile('/home/azuline/music.txt')Traceback(mostrecentcalllast):File"<stdin>",line1,in<module>File"/home/azuline/devel/tagfiles/tagfiles/__init__.py",line27,inTagFileraiseUnsupportedFileTypetagfiles.errors.UnsupportedFileTypeThe TagFile function takes a filepath as a parameter and returns the class
which corresponds to its container. If an unsupported filetype is passed in,
theUnsupportedFileTypeerror is raised. Each class presents the same metadata
interface, which have the following attributes:title:strversion:stralbum:strartist_album:List[str]catalog_number:strrelease_type:strcomment:strdate.year:intdate.date:strtrack_number:strtrack_total:strdisc_number:strdisc_total:strgenre:List[str]label:strartist={ArtistRoles.MAIN:List[str]ArtistRoles.FEATURE:List[str]ArtistRoles.REMIXER:List[str]ArtistRoles.PRODUCER:List[str]ArtistRoles.COMPOSER:List[str]ArtistRoles.CONDUCTOR:List[str]ArtistRoles.DJMIXER:List[str]}image_mime:strimage:bytesFields can be edited by setting new values to the attributes of the TagFile.
To edit the date, which is special, assign a string in the format of%Y-%m-%dor%Yto thedateattribute. To save the changes made to the tags, call thesave()method.Note: Image field is not currently editable.
Package: tag-fixer
Simple part of speech tag fixerThese functions are designed to fix POS tags.For tag_fixer(), the presumed format of the data is a list of [word,tag] or (word,tag) pairsl = [["The","DT"],["teacher","NNP"],["is","VBZ"],["awesome","JJ"]]
fixed_list = tag_fixer(l)For tag_fixer_sents(), the presumed format of that data is a list sentences that are lists of [word,tag] pairs.l2 = [[["The","DT"],["teacher","NNP"],["is","VBZ"],["awesome","JJ"]],[["This","DT"],["is","VBZ"],["another","JJ"]]]
tag_fixer_sents(l2)Note that either function will automatically capitalize tags (so the user doesn't have to hit the [shift] key)
Package: tag-formatter
tag-formatterTag-formatter is a Python Package designed to format strings that based on user-input.For example, tag-formatter can parse something such as:Hello there, {user}!Into something like:Hello there, John!InstallationYou can install tag-formatter using pip.pip install tag-formatterFeaturesHighly customizableUses regex delimiters that you can set.Uses a parser rather than things likestr.formatBecause this was meant for user input, str.format wouldn't work (invalid tags mean KeyErrors)str.replace on the other hand, would be too tedious and limited.Argument parsing for tagsBasic and function-based convertersDefault values for argumentsExampleYou can find more examples in theexamples folder.importrandomimporttagformatterclassUser:name='John'age=21parser=tagformatter.Parser()@parser.tag("user")defuser_tag(env):returnenv.user.name@user_tag.tag("age")defuser_age_tag(env):returnenv.user.age@parser.tag("random",alias="rng")defrng_tag(env,low:int=1,high:int=10):returnrandom.randint(low,high)print(parser.parse("{user}is{user.age}years old. Random number: {random:1, 20}",env={"user":User()}))
Package: tag-from-spotify
tag-from-spotifytag-from-spotifyis a Python CLI tool to fetch audio metadata from Spotify and tag them to your audio files.InstallationSince this package is meant to be an end-user app (not a library), it is highly recommended to install withpipx.pipx install tag-from-spotifyOf course, you can usepipas well.Authorization1. Create CredentialsTo fetch data from Spotify, you have to register this app toyour dashboardand create your Client ID and Client Sectet. You will see the detail process onthe Spotify Developer page, but note that you won't have to prepare your website URL or a redirection URL.2. Set Credentials to Environment VariablesThen add your Client ID and Client Secret to your environment variables like this:export SPOTIPY_CLIENT_ID='your-spotify-client-id'
export SPOTIPY_CLIENT_SECRET='your-spotify-client-secret'Usagetfsp DIR ALBUM_IDDIR: path to the directory containing audio files to set tagsALBUM_ID: the album ID, URI or URL such as the following examples:ID: 0WHIgko1oBSbayvwe9tdzeURI: spotify:album:0WHIgko1oBSbayvwe9tdzeURL:https://open.spotify.com/album/0WHIgko1oBSbayvwe9tdzeDevelopmentCreate an.envthat contains Spotify Client ID and Client Secret for the repository root (so you don't have to set them to the environment variables)SPOTIPY_CLIENT_ID=piyopiyopiyopiyo
SPOTIPY_CLIENT_SECRET=megamegamegamega
Package: tagg
# Tagg-Python Utility/Library> Tagg is a library and command line utility built to help you manipulate the data of [Tag-Github]## Installation```bash> pip install tagg-python```## Usage`tagg` and `autotagg` should run in the root of the data dir. If you wish to run them outside the data dir, use `-d datadir` to specify the data dir or `--force` to operate in a new data dir.### Tagg UtilityTagg cli tool provides basic functionalities to add, remove, update and validate tag and repo data.#### General```bash# Export data to jsontagg export > data.json# Enter REPL with history, autocomplete and basic syntax highlighting supporttagg shell```#### Tags```bash# List all tagstagg tags [list]# Add a tag named c++ in language domaintagg tags add language/c++# Remove a tag and all its links in repostagg tags remove language/c++# Show tag informationtagg tags show language/c++# Rename a tag and all its links in repostagg tags rename language/c++ language/cplusplus# Edit tag meta in VIMtagg tags edit language/c++# Validate tag datatagg tags validate```#### Repos```bash# List all repostagg repos [list]# Find all repos with one or more tagstagg repos links python,framework# Find all repos with one or more keywords in their names or descriptionstagg repos find django# Add a repo and fetch its meta from Githubtagg repos add django/django# Remove a repotagg repos remove django/django# Show repo informationtagg repos show django/django# Edit repo meta in VIMtagg repos edit django/django# Rename a repotagg repos rename django/django django/django2# Tag a repo with one or more tagstagg repos tag django/django language/c++# Untag a repotagg repos untag django/django [language/]c++# Get stats info of tagged repostagg repos link_stats# Validate repo datatagg repos validate```### Autotagg UtilityAutomatically tag repos according to their meta data. By default, it prints a list of suggested commands instead of actually modifying the data.```bash# Run on a repoautotagg owner/name# Run on all existing reposautotagg -a|--all# Get my repos from Github and run on themautotagg -g GITHUB_ACCOUNT# Get my repos and also my starred repos from Github and run on themautotagg -g GITHUB_ACCOUNT --starred# Get top1k repos from Github and run on themautotagg --top1k```Then to apply commands printed by `autotagg`, just pipe it to `tagg````bashautotag -a > pending_review.txtcat pending_review.txt | tagg```For more details option list please see --help of autotagg##### Autotagg Definition FileA json file that defines autotag criterias. Let's explain it with an example:```json{"default_type": "general","brands": {"twitter": ["twbs","twitter"]},"keywords":{"framework": ["/^django$/"],"python": ["python","/^py/"]}}```This defines three tags:* "brands/twitter" tag to be placed when the repo owner is "twbs" or "twitter"* "general/framework" tag to be placed when the repo name is exactly "django"* "general/python" tag to be placed when the repo name starts with "py" or the keyword "python" shows up anywhere in the repo name or the repo description# LicenseMIT[Tag-Github]: https://github.com/porter-io/tag-github
Package: taggeator
From a file with a tag description format like:apps:
  - name: fubar
    url: http://example.org/fubar
    description: a fubar app
    tags:
    - foo1
    - bar1

  - name: foo
    url: http://example.org/foo
    description: a foo app
    tags:
    - foo1
    - foo2

  - name: bar
    url: http://example.org/bar
    description: a bar app
    tags:
    - bar1
    - bar2Generates a new file after applying a template with the inverted file, that is,
a dict of tags with each app as a dict.As an example, with the template:Simple output for tageator

{% for item in categories | dictsort %}
- {{ item[0] }}
{%- for app in item[1] | sort(attribute='name') %}
  - {{ app.name }}: {{ app.description }} ({{ app.url }})
{%- endfor %}
{% endfor %}The previous input file will generate:Simple output for tageator


- bar1
  - bar: a bar app (http://example.org/bar)
  - fubar: a fubar app (http://example.org/fubar)

- bar2
  - bar: a bar app (http://example.org/bar)

- foo1
  - foo: a foo app (http://example.org/foo)
  - fubar: a fubar app (http://example.org/fubar)

- foo2
  - foo: a foo app (http://example.org/foo)
Package: tagged
taggedA Python version of JavaScript'stagged templates, mixed with Python 3'sf-strings.For a more involved example how this package can be used in practice, seehtm.pythat implements JSX-like syntax in plain Python.Installation$pip3installtaggedUsageThis package definestag, a decorator for creating new tags. Let's define a simple one:fromtaggedimporttag@tagdeft(strings,values):returnstrings,valuesNowtcan be called with a template string that can contain any Python 3 expression between{and}. The "static" parts of the string are listed instringsand the evaluated expressions are listed invalues.strings,values=t("1 +{2}equals {1 + 2}")# strings == ('1 + ', ' equals ', '')# values == (2, 3)Because the expressions are evaluated in the current context they can refer to local variables:a=[1,2,3]strings,values=t("the sum of{a}is {sum(a)}")# strings == ('the sum of ', ' is ', '')# values == ([1, 2, 3], 6)Double curly brackets are interpreted as a single textual curly bracket:strings,values=t("Inline a set between {{ and }} like this: {({1, 2, 3})}")# strings == ('Inline a set between { and } like this: ', '')# values == ({1, 2, 3},)rexampleLet's define a custom tagrexthat allows composing regular expressions from strings and other regular expressions.importrefromtaggedimporttag@tagdefrex(strings,values):pattern=strings[0]forvalue,stringinzip(values,strings[1:]):ifisinstance(value,re.Pattern):value=value.patternelifisinstance(value,str):value=re.escape(value)else:raiseTypeError("expected re.Pattern or str")pattern+="(?:"+value+")"+stringreturnre.compile(pattern)greeting=re.compile("Hello|Hi|Greetings")name="Python 3.7"rex("{greeting},{name}!")# re.compile('(?:Hello|Hi|Greetings), (?:Python\\ 3\\.7)!')DevelopmentRunning Tests$python3-munittestdiscover-stestsLicenseThis library is licensed under the MIT license. See./LICENSE.
Package: tagged-dataclasses
tagged_dataclassesSupport for tagged unions based on dataclasses via a lightweight mixin that is supported
by mypyfromtypingimportOptionalfromdataclassesimportdataclassfromtagged_dataclassesimportTaggedUnionclassA:pass@dataclassclassAB(A):pass@dataclassclassAC(A):pass@dataclassclassMyUnion(TaggedUnion[A]):# Optional is not optional here (this is for better support in PyCharm)first:Optional[AB]=Nonesecond:Optional[AC]=Nonex=MyUnion.from_value(AB())# support for many variationsifx.firstisnotNone:passelifx.secondisnotNone:pass# otherifx.kind==AB:x.value()elifx.kind==AC:x.value()
Package: tagged-users
tagged-usersExactly64 lines of code(including comments)Works onLinuxandMacOSOnly4KBAble to be piped out to other programsWhy?Many times, the person who posted the photo, puts all the
tags very close to each other, which makes is very difficult
click on the username.Here is an example of what I mean:Honestly, it is almost impossible to click on some of the tags.Installationpip3installtagged-usersUsageusage: tagged-users [-h] url

Get all the usernames of the people who got tagged in an Instagram post

positional arguments:
  url         URL to Instagram post

optional arguments:
  -h, --help  show this help message and exitLicenseMIT LicenseCopyright (c) 2019 Siddharth Dushantha
Package: taggercli
TaggercliDemoCLIReportReport DemoInstallationThe taggercli can be installed via pip.Runningpip install PLACEHOLDER PYPI NAMEwill install the CLIUsageThe main commands aretagger report createtagger tag allReport creationThereport createcommand first scans your AWS account (specified in your configuration, seeConfigurationfor more information)
and compares the tags of found resources with tags specified in your configuration file. A html report is generated showing the results from the comparison.If no region is specified via--regionthe default from the configuration file is used.Tag allThetag allcommand first scans a given AWS region and your global resources.
It displays a list of all the found resources and applies tags found in the configuration file.If no region is specified via--regionthe default from the configuration file is used.Supported resourcesPlease see the taggercoreREADMEfor a list of supported resources.PrerequisitesConfigurationtagger config createcreates a config file and writes the result to~/.tagger/config.iniThe profile provided should be present in your AWS configuration file. Per default boto looks at~/.aws/configfor the profile. Please make sure the specified profile has all the required permissions.Theconfig.iniis also used to specify the given tag schema.The config file iscase-sensitive!AWS PermissionsAWS Managed policiesReadOnlyAccessResourceGroupsandTagEditorFullAccessCustom policyEven though ResourceGroupsandTagEditorFullAccess allows access to the Resource Groups Tagging API additional permissions for the individual resources are necessary to perform the tagging operation.{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "acm:AddTagsToCertificate",
                "apigateway:POST",
                "apigateway:PUT",
                "cloudfront:TagResource",
                "cloudtrail:AddTags",
                "cloudwatch:TagResource",
                "dynamodb:TagResource",
                "ec2:CreateTags",
                "elasticache:AddTagsToResource",
                "elasticbeanstalk:AddTags",
                "elasticloadbalancing:AddTags",
                "es:AddTags",
                "events:TagResource",
                "firehose:TagDeliveryStream",
                "iam:TagRole",
                "iam:TagUser",
                "kinesis:AddTagsToStream",
                "lambda:TagResource",
                "logs:TagLogGroup",
                "rds:AddTagsToResource",
                "route53:ChangeTagsForResource",
                "s3:PutBucketTagging",
                "sns:TagResource",
                "sqs:TagQueue"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}DevelopmentInstall dev dependencies:pipenv install -e .[dev]Run tests:toxRun black for code formatting:tox -e format
Package: taggercore
TaggercoreAboutTaggercore contains utility classes for scanning AWS resources and applying tags to them.
Theusecasepackage contains opinionated functions for performing tasks like scanning a region and global resources (e.g. IAM) or comparing resources to a certain tagging schema (e.g.create_report.py).Supported resourcesResources supported (scanning + tagging)ResourceNotesacm.certificateapigateway.apisapigateway.restapiscloudfront.distributioncloudtrail.trailglobal trails are currently not supportedcloudwatch.alarmdynamodb.tableec2.addressec2.customer-gatewayec2.flow-logec2.imageec2.instanceself owned onlyec2.internetgatewayec2.keypairsec2.launch-templateec2.natgatewayec2.networkaclec2.route-tableec2.securitygroupec2.snapshotec2.subnetec2.volumeec2.vpcec2.vpc-peering-connectionelasticache.clusterelasticache.snapshotelasticbeanstalk.applicationelasticloadbalacing.loadbalancerv1(classic) and v2(application,network)es.domainfirehose.deliverystreamiam.roleiam.userkinesis.streamdata streamslambda.functionlogs.log-grouprds.clusterrds.dbrds.secgrproute53.healthcheckroute53.hostedzonesns.topics3.bucketsqs.queueInstallationTaggercore can be installed by runningpip install taggercoreDevelopmentInstall dev dependencies:pipenv install -e .[dev]Run tests:toxRun black for code formatting:tox -e format
Package: taggerscript
TaggerTagger is a scripting language for Discord bot. It can be used from tag command to user automation moderation. It is simple but powerful. Users cannot run code that can harm your bot. You can add new function and class to it in a simple way.Example{do
    {msg.set("React with :heart: to claim this present")}
    {msg.wait_for_reaction(":heart:")}
    {msg.set("Just kidding there is no present")}
}Check example for moreInstallPIPpip install taggerscriptPoetrypoetry add taggerscriptgit clonegit clone https://github.com/najis-poop/TaggerScriptDocumentationcoming soonFeedbackTagger still in development. Any bug should be reported quickly by creating issue in github issue.
Package: tagging-module
Tagging ModuleA lightweight rule based tech content tagging module for PythonClass OverviewTheTaggingServiceclass is designed to provide a tagging service. It uses thetagging_systemmodule to assign tags to content based on predefined rules. The tagging rules are specified in a YAML file.You may directly use it from this repo or install via Pip.pip install tagging-moduleConstructor__init__(self, rules_path: str = None)The constructor initializes aTaggingServiceobject.Parametersrules_path(optional): A string representing the path to the YAML file containing the tagging rules. If not provided, the default rules file path (tagging_module/config/rules.yml) is used.ExceptionsFileNotFoundError: Raised if the providedrules_pathis not a valid file path.Examplefromtagging_module.tagging_serviceimportTaggingService# Using the default rules file pathservice=TaggingService()# Providing a custom rules file pathservice=TaggingService(rules_path="path/to/custom_rules.yml")Methodsassign_tags(self, content: str) -> List[str]This method assigns tags to the provided content based on the defined tagging rules.Parameterscontent: A string representing the content to be tagged.ReturnsA list of strings representing the assigned tags for the content.Examplefromtagging_module.tagging_serviceimportTaggingService# Assuming the rules file contains rules for tagging different types of contentservice=TaggingService()content="This is a sample content."tags=service.assign_tags(content)print(tags)# Output: ['sample', 'content']Note: The output tags may vary based on the specific tagging rules defined in the rules file.