c9ai
Version:
Universal AI assistant with vibe-based workflows, hybrid cloud+local AI, and comprehensive tool integration
252 lines • 122 kB
JSON
{
"topics": {
"bulk upload implementation": {
"definition": "This document provides comprehensive documentation for the bulk CSV upload functionality implemented in the Xpress email marketing platform. The system allows users to upload multiple subscribers via CSV files with automatic list assignment and comprehensive validation.",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/BULK_UPLOAD_IMPLEMENTATION.md"
},
"deployment guide": {
"definition": "This guide covers deploying the enterprise-grade Xpress email marketing platform to production environments, including configuration for GDPR compliance, security hardening, and monitoring features.",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/DEPLOYMENT_GUIDE.md"
},
"email marketing": {
"definition": "This document outlines the technical approach for building a scalable email marketing SaaS platform using AWS SES for email delivery.",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/EMAIL_MARKETING.md"
},
"enterprise features": {
"definition": "This document outlines the enterprise-grade features implemented to enhance the Xpress email marketing platform's security, compliance, and monitoring capabilities.",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/ENTERPRISE_FEATURES.md"
},
"implementation summary": {
"definition": "This document summarizes the successful completion of GDPR compliance implementation along with the two most critical enterprise improvements: **Security Hardening** and **Monitoring & Alerting** for the Xpress email marketing platform.",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/IMPLEMENTATION_SUMMARY.md"
},
"razorpay setup": {
"definition": "This application uses Razorpay for payment processing. Follow these steps to configure Razorpay for your application:",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/RAZORPAY_SETUP.md"
},
"xpress": {
"definition": "* Run `mix setup` to install and setup dependencies",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on xpress implementation.",
"examples": "Implementation examples available in xpress project",
"source": "/Users/hebbarp/xpress/README.md"
},
"tutorial": {
"definition": "Building a Sendy-like email marketing system with Phoenix and AWS SES.",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/TUTORIAL.md"
},
"topbar": {
"definition": "@license MIT topbar 2.0.0, 2023-02-04 https://buunguyen.github.io/topbar Copyright (c) 2021 Buu Nguyen",
"trends": "Active js development with inline documentation",
"perspectives": "Technical implementation in js programming language",
"examples": "Code examples available in topbar.js",
"source": "/Users/hebbarp/xpress/assets/vendor/topbar.js"
},
"bandit": {
"definition": "",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on bandit implementation.",
"examples": "{:bandit, \"~> 1.0\"} | 2. Add the following `adapter:` line to your endpoint configuration in `config/config.exs`, as in the following example: | # config/config.exs\n config :your_app, YourAppWeb.Endpoint,\n adapter: Bandit.PhoenixAdapter, # <---- ADD THIS LINE\n url: [host: \"localhost\"],\n render_errors: ... | For less formal usage, you can also start Bandit using the same configuration\noptions via the `Bandit.start_link/1` function: | # Start an http server on the default port 4000, serving MyApp.MyPlug\nBandit.start_link(plug: MyPlug) | ## Configuration\nA number of options are defined when starting a server. The complete list is\ndefined by the [`t:Bandit.options/0`](https://hexdocs.pm/bandit/Bandit.html#summary) type.\n## Setting up an HTTPS Server\nBy far the most common stumbling block encountered when setting up an HTTPS\nserver involves configuring key and certificate data. Bandit is comparatively\neasy to set up in this regard, with a working example looking similar to the\nfollowing: | def deps do\n [\n {:bandit, \"~> 1.0\"}\n ]\nend | Documentation can be found at [https://hexdocs.pm/bandit](https://hexdocs.pm/bandit).\n# License\nMIT",
"source": "/Users/hebbarp/xpress/deps/bandit/README.md"
},
"bcrypt elixir": {
"definition": "[](https://travis-ci.com/riverrun/bcrypt_elixir)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on bcrypt elixir implementation.",
"examples": "def deps do\n [\n {:bcrypt_elixir, \"~> 3.0\"}\n ]\n end | If you are using Erlang 19 or below: | def deps do\n [\n {:bcrypt_elixir, \"~> 0.12\"}\n ]\n end | 2. Make sure you have a C compiler installed.\nSee the [Comeonin wiki](https://github.com/riverrun/comeonin/wiki/Requirements) for details.\n3. Optional: during tests (and tests only), you may want to reduce the number of rounds\nso it does not slow down your test suite. If you have a config/test.exs, you should\nadd: | config :bcrypt_elixir, :log_rounds, 4",
"source": "/Users/hebbarp/xpress/deps/bcrypt_elixir/README.md"
},
"castore": {
"definition": "[](https://github.com/elixir-mint/castore/actions/workflows/ci.yml)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on castore implementation.",
"examples": "def deps do\n [\n {:castore, \"~> 1.0\"}\n ]\nend | Then, run `$ mix deps.get`.\n## Usage\nThis is a micro-library whose only job is storing an up-to-date CA certificate store. The only provided function is `CAStore.file_path/0`, which returns the path of the CA certificate store file. | CAStore.file_path()\n#=> /Users/me/castore/_build/dev/lib/castore/priv/cacerts.pem\"",
"source": "/Users/hebbarp/xpress/deps/castore/README.md"
},
"certifi": {
"definition": "[](https://github.com/certifi/erlang-certifi/actions/workflows/erlang.yml)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on certifi implementation.",
"examples": "CaCerts = certifi:cacerts(),\nSslOptions = [{verify, verify_peer},\n {depth, 99},\n {cacerts, CaCerts}],\nssl:connect( \"example.com\", 443, SslOptions ). | You can also retrieve the path to the file and load it by yourself if needed: | Path = certifi:cacertfile(). | ## Development\nTesting: | rebar3 eunit | Documentation: | rebar3 ex_doc",
"source": "/Users/hebbarp/xpress/deps/certifi/README.md"
},
"comeonin": {
"definition": "[](https://travis-ci.com/riverrun/comeonin)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on comeonin implementation.",
"examples": "Implementation examples available in comeonin project",
"source": "/Users/hebbarp/xpress/deps/comeonin/README.md"
},
"db connection": {
"definition": "Database connection behaviour and database connection pool designed for",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on db connection implementation.",
"examples": "Implementation examples available in db_connection project",
"source": "/Users/hebbarp/xpress/deps/db_connection/README.md"
},
"decimal": {
"definition": "Decimal represents values internally using three integers: a sign, a coefficient, and an exponent.",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on decimal implementation.",
"examples": "Decimal.new(_sign = 1, _coefficient = 42, _exponent = 0) #=> Decimal.new(\"42\")\nDecimal.new(-1, 42, 0) #=> Decimal.new(\"-42\")\nDecimal.new(1, 42, -1) #=> Decimal.new(\"4.2\")\nDecimal.new(1, 42, -20) #=> Decimal.new(\"4.2E-19\")\nDecimal.new(1, 42, 20) #=> Decimal.new(\"4.2E+21\")\nDecimal.new(1, 123456789987654321, -9) #=> Decimal.new(\"123456789.987654321\") | For calculations, the amount of desired precision - that is, the number of\ndecimal digits in the coefficient - can be specified.\n## Usage\nAdd Decimal as a dependency in your `mix.exs` file: | def deps do\n [{:decimal, \"~> 2.0\"}]\nend | Next, run `mix deps.get` in your shell to fetch and compile `Decimal`. Start an\ninteractive Elixir shell with `iex -S mix`: | iex> alias Decimal, as: D\niex> D.add(6, 7)\nDecimal.new(\"13\")\niex> D.div(1, 3)\nDecimal.new(\"0.3333333333333333333333333333\")\niex> D.new(\"0.33\")\nDecimal.new(\"0.33\") | ### Precision and rounding\nUse `:precision` option to limit the amount of decimal digits in the\ncoefficient of any calculation result: | iex> D.Context.set(%D.Context{D.Context.get() | precision: 9})\n:ok\niex> D.div(100, 3)\nDecimal.new(\"33.3333333\")\niex> D.Context.set(%D.Context{D.Context.get() | precision: 2})\n:ok\niex> D.div(100, 3)\nDecimal.new(\"33\") | The `:rounding` option specifies the algorithm and precision of the rounding\noperation: | iex> D.Context.set(%D.Context{D.Context.get() | rounding: :half_up})\n:ok\niex> D.div(31, 2)\nDecimal.new(\"16\")\niex> D.Context.set(%D.Context{D.Context.get() | rounding: :floor})\n:ok\niex> D.div(31, 2)\nDecimal.new(\"15\") | ### Comparisons\nUsing comparison operators (`<`, `=`, `>`) with two or more decimal digits may\nnot produce accurate result. Instead, use comparison functions. | ### Flags and trap enablers\nWhen an exceptional condition is signalled, its flag is set in the current\ncontext. `Decimal.Error` will be raised if the trap enabler is set. | `:inexact` and `:rounded` flag were signalled above because the result of the\noperation was inexact given the context's precision and had to be rounded to\nfit the precision. `Decimal.Error` was not raised because the signals' trap\nenablers weren't set. | iex> D.Context.set(%D.Context{D.Context.get() | traps: D.Context.get().traps ++ [:inexact]})\n:ok\niex> D.div(31, 2)\n** (Decimal.Error) | The default trap enablers, such as `:division_by_zero`, can be unset:",
"source": "/Users/hebbarp/xpress/deps/decimal/README.md"
},
"license": {
"definition": "Copyright (c) 2023 Chris McCord Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Softwa",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/deps/dns_cluster/LICENSE.md"
},
"dns cluster": {
"definition": "Simple DNS clustering for distributed Elixir nodes.",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on dns cluster implementation.",
"examples": "def deps do\n [\n {:dns_cluster, \"~> 0.1.1\"}\n ]\nend | Next, you can configure and start the cluster by adding it to your supervision\ntree in your `application.ex`: | children = [\n {Phoenix.PubSub, ...},\n {DNSCluster, query: Application.get_env(:my_app, :dns_cluster_query) || :ignore},\n MyAppWeb.Endpoint\n] | If you are deploying with Elixir releases, the release must be set to support longnames and\nthe node must be named. These can be set in your `rel/env.sh.eex` file: | #!/bin/sh\nexport RELEASE_DISTRIBUTION=name\nexport RELEASE_NODE=\"myapp@fully-qualified-host-or-ip\" | By default, nodes from the same release will have the same cookie. If you want different\napplications or releases to connect to each other, then you must set the `RELEASE_COOKIE`,\neither in your deployment platform or inside `rel/env.sh.eex`: | #!/bin/sh\n...\nexport RELEASE_COOKIE=\"my-app-cookie\"",
"source": "/Users/hebbarp/xpress/deps/dns_cluster/README.md"
},
"ecto": {
"definition": "<img width=\"250\" src=\"https://github.com/elixir-ecto/ecto/raw/master/guides/images/logo.png#gh-light-mode-only\" alt=\"Ecto\">",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on ecto implementation.",
"examples": "def deps do\n [\n {:ecto, \"~> 3.10\"}\n ]\nend | ## About\nEcto is a toolkit for data mapping and language integrated query for Elixir. Here is an example: | defp deps do\n [\n {:ecto_sql, \"~> 3.0\"},\n {:postgrex, \">= 0.0.0\"}\n ]\nend | Then run `mix deps.get` in your shell to fetch the dependencies. If you want to use another database, just choose the proper dependency from the table above.\nFinally, in the repository definition, you will need to specify the `adapter:` respective to the chosen dependency. For PostgreSQL it is: | defmodule MyApp.Repo do\n use Ecto.Repo,\n otp_app: :my_app,\n adapter: Ecto.Adapters.Postgres,\n ... | ### IPv6 support\nIf your database's host resolves to ipv6 address you should\nadd `socket_options: [:inet6]` to configuration block like below: | import Mix.Config\nconfig :my_app, MyApp.Repo,\n hostname: \"db12.dc0.comp.any\",\n socket_options: [:inet6],\n ...",
"source": "/Users/hebbarp/xpress/deps/ecto/README.md"
},
"ecto sql": {
"definition": "[](https://github.com/elixir-ecto/ecto_sql/actions)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on ecto sql implementation.",
"examples": "Implementation examples available in ecto_sql project",
"source": "/Users/hebbarp/xpress/deps/ecto_sql/README.md"
},
"elixir make": {
"definition": "[](https://github.com/elixir-lang/elixir_make/actions)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on elixir make implementation.",
"examples": "def deps do\n [{:elixir_make, \"~> 0.4\", runtime: false}]\nend | Still in your `mix.exs` file, you will need to add `:elixir_make` to your list of compilers in `project/0`: | compilers: [:elixir_make] ++ Mix.compilers, | And that's it. The command above will invoke `make` for Unix, `nmake` for Windows and `gmake` for FreeBSD and OpenBSD. A \"Makefile\" file is expected at your project root for Unix systems and \"Makefile.win\" for Windows systems. Run `mix help compile.elixir_make` for more information and options.\n## Publishing a package to Hex.pm\nWhen publishing a package to Hex.pm using `elixir_make` requires you to add\nany file (such as the Makefile and any source files) to the `files` option.\nSee [the hex docs](https://hex.pm/docs/publish#adding-metadata-to-code-classinlinemixexscode) | defp package do\n [\n # ...\n files: [\n \"lib\", \"LICENSE\", \"mix.exs\", \"README.md\", # These are the default files\n \"src/*.[ch]\", \"Makefile\"], # You will need to add something like this.\n # ...\n ]\n end | ## License\nSame as Elixir.",
"source": "/Users/hebbarp/xpress/deps/elixir_make/README.md"
},
"ex aws": {
"definition": "[](https://github.com/ex-aws/ex_aws/actions/workflows/on-push.yml)",
"trends": "Based on project analysis: active development with 5 key features",
"perspectives": "Open source project with community contributions. Project focuses on ex aws implementation.",
"examples": "defp deps do\n [\n {:ex_aws, \"~> 2.1\"},\n {:ex_aws_s3, \"~> 2.0\"},\n {:hackney, \"~> 1.9\"},\n {:sweet_xml, \"~> 0.6\"},\n ]\nend | With these deps you can use `ExAws` precisely as you're used to: | # make a request (with the default region)\nExAws.S3.list_objects(\"my-bucket\") |> ExAws.request()\n# or specify the region\nExAws.S3.list_objects(\"my-bucket\") |> ExAws.request(region: \"us-west-1\")\n# some operations support streaming\nExAws.S3.list_objects(\"my-bucket\") |> ExAws.stream!() |> Enum.to_list() | ### AWS Key configuration\nExAws requires valid AWS keys in order to work properly. ExAws by default does\nthe equivalent of: | config :ex_aws,\n access_key_id: [{:system, \"AWS_ACCESS_KEY_ID\"}, :instance_role],\n secret_access_key: [{:system, \"AWS_SECRET_ACCESS_KEY\"}, :instance_role] | This means it will try to resolve credentials in order:\n* Look for the AWS standard `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment variables\n* Resolve credentials with IAM\n * If running inside ECS and a [task role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) has been assigned it will use it\n * Otherwise it will fall back to the [instance role](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)\nAWS CLI config files are supported, but require an additional dependency: | {:configparser_ex, \"~> 4.0\"} | You can then add `{:awscli, \"profile_name\", timeout}` to the above config and\nit will pull information from `~/.aws/config` and `~/.aws/credentials`\nAlternatively, if you already have a profile name set in the `AWS_PROFILE` environment\nvariable, you can use that with `{:awscli, :system, timeout}` | config :ex_aws,\n access_key_id: [{:system, \"AWS_ACCESS_KEY_ID\"}, {:awscli, \"default\", 30}, :instance_role],\n secret_access_key: [{:system, \"AWS_SECRET_ACCESS_KEY\"}, {:awscli, \"default\", 30}, :instance_role] | For role based authentication via `role_arn` and `source_profile` an additional\ndependency is required: | {:ex_aws_sts, \"~> 2.0\"} | Further information on role based authentication is provided in said dependency.\n#### Session token configuration\nAlternatively, you can also provide `AWS_SESSION_TOKEN` to `security_token` to authenticate\nwith session token: | config :ex_aws,\n access_key_id: {:system, \"AWS_ACCESS_KEY_ID\"},\n security_token: {:system, \"AWS_SESSION_TOKEN\"},\n secret_access_key: {:system, \"AWS_SECRET_ACCESS_KEY\"} | ### Hackney configuration\nExAws by default uses [hackney](https://github.com/benoitc/hackney) to make\nHTTP requests to AWS API. You can modify the options as such: | config :ex_aws, :hackney_opts,\n follow_redirect: true,\n recv_timeout: 30_000 | ### AWS Region Configuration.\nYou can set the region used by default for requests. | config :ex_aws,\n region: \"us-west-2\", | Alternatively, the region can be set in an environment variable: | config :ex_aws,\n region: {:system, \"AWS_REGION\"} | ### JSON Codec Configuration\nThe default JSON codec is Jason. You can choose a different one: | config :ex_aws,\n json_codec: Poison | ### Path Normalization\nPaths that include multiple consecutive /'s will by default be normalized\nto a single slash. There are cases when paths need to be literal (S3) and\nthis normalization behaviour can be turned off via configuration: | config :ex_aws,\n normalize_path: false | #### ECS RunTask | # default values shown below\nconfig :ex_aws, :retries,\n max_attempts: 10,\n base_backoff_in_ms: 10,\n max_backoff_in_ms: 10_000 | * `max_attempts` is the maximum number of possible attempts with backoffs in between each one\n* `max_attempts_client` may be set to a different value for client errors (4xx) (default is `max_attempts`)\n* `base_backoff_in_ms` corresponds to the `base` value described in the blog post\n* `max_backoff_in_ms` corresponds to the `cap` value described in the blog post\n## Testing\nIf you want to run `mix test`, you'll need to have a local `dynamodb` running\non port 8000: | docker run --rm -d -p 8000:8000 amazon/dynamodb-local -jar DynamoDBLocal.jar -port 8000",
"source": "/Users/hebbarp/xpress/deps/ex_aws/README.md"
},
"changelog": {
"definition": "All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](",
"trends": "All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/deps/ex_aws_ses/CHANGELOG.md"
},
"ex aws ses": {
"definition": "[](https://hex.pm/packages/ex_aws_ses)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on ex aws ses implementation.",
"examples": "def deps do\n [\n {:ex_aws, \"~> 2.0\"},\n {:ex_aws_ses, \"~> 2.0\"},\n {:poison, \"~> 3.0\"},\n {:hackney, \"~> 1.9\"},\n ]\nend",
"source": "/Users/hebbarp/xpress/deps/ex_aws_ses/README.md"
},
"expo": {
"definition": "[](https://hex.pm/packages/expo)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on expo implementation.",
"examples": "Expo.PO.parse_file!(\"priv/gettext/default.pot\")\n#=> %Expo.Messages{...} | It can also *write* well-formed PO, POT, and MO files: | \"priv/gettext/default.pot\"\n|> Expo.PO.parse_file!()\n|> Expo.PO.compose()\n|> then(fn content -> File.write!(\"priv/gettext/copy.pot\", content) end) | This library can also parse [`Plural-Form`\nheaders](https://www.gnu.org/software/gettext/manual/html_node/Plural-forms.html)\nin PO or POT files, and ships with a built-in list of languages and their plural\nforms. You can find which plural form to use for a given *amount* by using\n`Expo.PluralForms.index/2`: | {:ok, plural_form} = Expo.PluralForms.plural_form(\"de\")\nExpo.PluralForms.index(plural_form, 1)\n#=> 0\nExpo.PluralForms.index(plural_form, 213)\n#=> 1",
"source": "/Users/hebbarp/xpress/deps/expo/README.md"
},
"file system": {
"definition": "[](https://hex.pm/packages/file_system)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on file system implementation.",
"examples": "open /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg | On newer versions this file doesn't exist. But it still should work just fine as long as you have xcode installed.\n## Usage\nAdd `file_system` to the `deps` of your mix.exs | ### Subscription API\nYou can spawn a worker and subscribe to events from it: | {:ok, pid} = FileSystem.start_link(dirs: [\"/path/to/some/files\"])\nFileSystem.subscribe(pid) | or | {:ok, pid} = FileSystem.start_link(dirs: [\"/path/to/some/files\"], name: :my_monitor_name)\nFileSystem.subscribe(:my_monitor_name) | The `pid` you subscribed from will now receive messages like: | {:file_event, worker_pid, {file_path, events}} | and | {:file_event, worker_pid, :stop} | ### Example Using GenServer | ## Backend Options\nFor each platform, you can pass extra options to the underlying listener\nprocess.\nEach backend supports different extra options, check backend module\ndocumentation for more details.\nHere is an example to get instant notifications on file changes for MacOS: | FileSystem.start_link(dirs: [\"/path/to/some/files\"], latency: 0, watch_root: true)",
"source": "/Users/hebbarp/xpress/deps/file_system/README.md"
},
"finch": {
"definition": "<img alt=\"Finch\" height=\"350px\" src=\"assets/Finch_logo_onWhite.png#gh-light-mode-only\">",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on finch implementation.",
"examples": "children = [\n {Finch, name: MyFinch}\n] | Or, in rare cases, dynamically: | Finch.start_link(name: MyFinch) | Once you have started your instance of Finch, you are ready to start making requests: | Finch.build(:get, \"https://hex.pm\") |> Finch.request(MyFinch) | When using HTTP/1, Finch will parse the passed in URL into a `{scheme, host, port}`\ntuple, and maintain one or more connection pools for each `{scheme, host, port}` you\ninteract with.\nYou can also configure a pool size and count to be used for specific URLs that are\nknown before starting Finch. The passed URLs will be parsed into `{scheme, host, port}`,\nand the corresponding pools will be started. See `Finch.start_link/1` for configuration\noptions. | children = [\n {Finch,\n name: MyConfiguredFinch,\n pools: %{\n :default => [size: 10],\n \"https://hex.pm\" => [size: 32, count: 8]\n }}\n] | {Finch,\n name: MyFinch,\n pools: %{\n default: [conn_opts: [transport_opts: [keep_secrets: true]]]\n }} | There are two different ways to specify this file:\n1. The `:ssl_key_log_file` connection option in your pool configuration. For example: | {Finch,\n name: MyFinch,\n pools: %{\n default: [\n conn_opts: [\n ssl_key_log_file: \"/writable/path/to/the/sslkey.log\"\n ]\n ]\n }} | 2. Alternatively, you could also set the `SSLKEYLOGFILE` environment variable.\n<!-- MDOC !-->\n## Installation\nThe package can be installed by adding `finch` to your list of dependencies in `mix.exs`: | def deps do\n [\n {:finch, \"~> 0.19\"}\n ]\nend | The docs can be found at [https://hexdocs.pm/finch](https://hexdocs.pm/finch).",
"source": "/Users/hebbarp/xpress/deps/finch/README.md"
},
"code of conduct": {
"definition": "Contact: Philip Sampaio Silva - philip.sampaio+flokiconduct@gmail.com",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/deps/floki/CODE_OF_CONDUCT.md"
},
"contributing": {
"definition": "We want to encourage you to contribute to Floki with documentation, code and ideas. To do so, you can read the existing docs and take a look at our source code through [closed pull requests](https://g",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/deps/floki/CONTRIBUTING.md"
},
"floki": {
"definition": "[](https://github.com/philss/floki/actions)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on floki implementation.",
"examples": "Here are some queries that you can perform (with return examples): | {:ok, document} = Floki.parse_document(html)\nFloki.find(document, \"p.headline\")\n# => [{\"p\", [{\"class\", \"headline\"}], [\"Floki\"]}]\ndocument\n|> Floki.find(\"p.headline\")\n|> Floki.raw_html()\n# => <p class=\"headline\">Floki</p> | Each HTML node is represented by a tuple like:\n {tag_name, attributes, children_nodes}\nExample of node:\n {\"p\", [{\"class\", \"headline\"}], [\"Floki\"]}\nSo even if the only child node is the element text, it is represented inside a list.\n## Installation\nAdd Floki to your `mix.exs`: | defp deps do\n [\n {:floki, \"~> 0.38.0\"}\n ]\nend | After that, run `mix deps.get`.\nIf you are running on [Livebook](https://livebook.dev) or a script, you can install with `Mix.install/2`: | Mix.install([\n {:floki, \"~> 0.38.0\"}\n]) | sh benchs/extract.sh\nmix run benchs/parse_document.exs | Extracting the files is needed only once.\n#### Using `html5ever` as the HTML parser\nThis dependency is written with a NIF using [Rustler](https://github.com/rusterlium/rustler), but\nyou don't need to install anything to compile it thanks to [RustlerPrecompiled](https://hexdocs.pm/rustler_precompiled/). | defp deps do\n [\n {:floki, \"~> 0.38.0\"},\n {:html5ever, \"~> 0.16.0\"}\n ]\nend | Run `mix deps.get` and compiles the project with `mix compile` to make sure it works.\nThen you need to configure your app to use `html5ever`: | # in config/config.exs\nconfig :floki, :html_parser, Floki.HTMLParser.Html5ever | Notice that you can pass the HTML parser as an option in `parse_document/2` and `parse_fragment/2`.\n#### Using `fast_html` as the HTML parser\nA C compiler, GNU\\Make and CMake need to be installed on the system in order to\ncompile lexbor.\nFirst, add `fast_html` to your dependencies: | defp deps do\n [\n {:floki, \"~> 0.38.0\"},\n {:fast_html, \"~> 2.0\"}\n ]\nend | Run `mix deps.get` and compiles the project with `mix compile` to make sure it works.\nThen you need to configure your app to use `fast_html`: | # in config/config.exs\nconfig :floki, :html_parser, Floki.HTMLParser.FastHtml | ## More about Floki API\nTo parse a HTML document, try: | html = \"\"\"\n <html>\n <body>\n <div class=\"example\"></div>\n </body>\n </html>\n\"\"\"\n{:ok, document} = Floki.parse_document(html)\n# => {:ok, [{\"html\", [], [{\"body\", [], [{\"div\", [{\"class\", \"example\"}], []}]}]}]} | To find elements with the class `example`, try: | Floki.find(document, \".example\")\n# => [{\"div\", [{\"class\", \"example\"}], []}] | To convert your node tree back to raw HTML (spaces are ignored): | document\n|> Floki.find(\".example\")\n|> Floki.raw_html()\n# => <div class=\"example\"></div> | To fetch some attribute from elements, try: | Floki.attribute(document, \".example\", \"class\")\n# => [\"example\"] | You can get attributes from elements that you already have: | document\n|> Floki.find(\".example\")\n|> Floki.attribute(\"class\")\n# => [\"example\"] | If you want to get the text from an element, try: | document\n|> Floki.find(\".headline\")\n|> Floki.text()\n# => \"Floki\"",
"source": "/Users/hebbarp/xpress/deps/floki/README.md"
},
"gen smtp": {
"definition": "[](https://hex.pm/packages/gen_smtp)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on gen smtp implementation.",
"examples": "gen_smtp_client:send({\"whatever@test.com\", [\"andrew@hijacked.us\"],\n \"Subject: testing\\r\\nFrom: Andrew Thompson <andrew@hijacked.us>\\r\\nTo: Some Dude <foo@bar.com>\\r\\n\\r\\nThis is the email body\"},\n [{relay, \"smtp.gmail.com\"}, {username, \"me@gmail.com\"}, {password, \"mypassword\"}]). | # RSA\nopenssl genrsa -out private-key.pem 1024\nopenssl rsa -in private-key.pem -out public-key.pem -pubout\n# Ed25519 - Erlang/OTP 24.1+ only!\nopenssl genpkey -algorithm ed25519 -out private-key.pem\nopenssl pkey -in private-key.pem -pubout -out public-key.pem\n# DKIM DNS record p value for Ed25519 must only contain Base64 encoded public key, without ASN.1\nopenssl asn1parse -in public-key.pem -offset 12 -noout -out /dev/stdout | openssl base64 | To send DKIM-signed email: | For using Ed25519 you need to set the option `{a, 'ed25519-sha256'}`.\nDon't forget to put your public key to `foo.bar._domainkey.example.com` TXT DNS record as something like\nRSA: | v=DKIM1; g=*; k=rsa; p=MIGfMA0GCSqGSIb3DQEBA...... | Ed25519: | v=DKIM1; g=*; k=ed25519; p=MIGfMA0GCSqGSIb3DQEBA...... | See RFC6376 for more details.\n## Server Example\n`gen_smtp` ships with a simple callback server example, `smtp_server_example`. To start the SMTP server with this as the callback module, issue the following command: | gen_smtp_server:start(smtp_server_example).\ngen_smtp_server starting at nonode@nohost\nlistening on {0,0,0,0}:2525 via tcp\n{ok,<0.33.0>} | By default it listens on 0.0.0.0 port 2525. You can telnet to it and test it: | You can configure the server in general, each SMTP session, and the callback module, for example: | gen_smtp_server:start(\n smtp_server_example,\n [{sessionoptions, [{allow_bare_newlines, fix},\n {callbackoptions, [{parse, true}]}]}]). | gen_smtp_client:send(\n {\"whatever@test.com\", [\"andrew@hijacked.us\"], \"Subject: testing\\r\\nFrom: Andrew Thompson \\r\\nTo: Some Dude \\r\\n\\r\\nThis is the email body\"},\n [{relay, \"localhost\"}, {port, 2525}]). | {deps, [\n {eiconv, \"1.0.0\"}\n]}.",
"source": "/Users/hebbarp/xpress/deps/gen_smtp/README.md"
},
"gettext": {
"definition": "[](https://hex.pm/packages/gettext)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on gettext implementation.",
"examples": "defp deps do\n [\n {:gettext, \">= 0.0.0\"}\n ]\nend | Documentation for `Gettext` is [available on Hex][docs-gettext].\n## Usage\nTo use Gettext, define a **Gettext backend**: | defmodule MyApp.Gettext do\n use Gettext.Backend, otp_app: :my_app\nend | and invoke the Gettext API, which consists of the `*gettext` macros that get imported if you `use Gettext`: | use Gettext, backend: MyApp.Gettext\n# Simple message\ngettext(\"Here is one string to translate\")\n# Plural message\nnumber_of_apples = 4\nngettext(\"The apple is ripe\", \"The apples are ripe\", number_of_apples)\n# Domain-based message\ndgettext(\"errors\", \"Here is an error message to translate\") | Messages in Gettext are stored in Portable Object files (`.po`). Such files must be placed at `priv/gettext/LOCALE/LC_MESSAGES/DOMAIN.po`, where `LOCALE` is the locale and `DOMAIN` is the domain (the default domain is called `default`).\nFor example, the message to `pt_BR` of the first two `*gettext` calls in the snippet above must be placed in the `priv/gettext/pt_BR/LC_MESSAGES/default.po` file with contents: | msgid \"Here is one string to translate\"\nmsgstr \"Aqui está um texto para traduzir\"\nmsgid \"Here is the string to translate\"\nmsgid_plural \"Here are the strings to translate\"\nmsgstr[0] \"Aqui está o texto para traduzir\"\nmsgstr[1] \"Aqui estão os textos para traduzir\" | gettext(\"Welcome back!\") | 2. Once changes to the source are complete, automatically sync all existing entries to `.pot` (template files) in `priv/gettext` by running: | mix gettext.extract | 3. You can then merge `.pot` files into locale-specific `.po` files: | # Merge .pot into all locales\n mix gettext.merge priv/gettext\n # Merge .pot into one specific locale\n mix gettext.merge priv/gettext --locale en",
"source": "/Users/hebbarp/xpress/deps/gettext/README.md"
},
"news": {
"definition": "1.24.1 - 2025-05-26 ------------------- - fix: remove unused variable warning in hackney.erl 1.24.0 - 2025-05-26 ------------------- - security: fix basic auth credential exposure vulnerability - secu",
"trends": "Documentation maintained and updated regularly",
"perspectives": "Various implementation approaches documented",
"examples": "Examples and usage patterns available in documentation",
"source": "/Users/hebbarp/xpress/deps/hackney/NEWS.md"
},
"hackney": {
"definition": "[](https://github.com/benoitc/hackney/actions?query=workflow%3Abuild)",
"trends": "Based on project analysis: active development with 8 key features",
"perspectives": "Open source project with community contributions. Project focuses on hackney implementation.",
"examples": "{deps, [\n ....\n {hackney, \".*\", {git, \"git://github.com/benoitc/hackney.git\", {branch, \"master\"}}}\n]}. | ## Basic usage\nThe basic usage of hackney is:\n### Start hackney\nhackney is an\n[OTP](http://www.erlang.org/doc/design_principles/users_guide.html)\napplication. You have to start it first before using any of the functions.\nThe hackney application will start the default socket pool for you.\nTo start in the console run: | $ ./rebar3 shell | It is suggested that you install rebar3 user-wide as described [here](http://blog.erlware.org/rebar3-features-part-1-local-install-and-upgrade/).\nThis fixes zsh (and maybe other shells) escript-related bugs. Also this should speed things up. | > application:ensure_all_started(hackney).\nok | It will start hackney and all of the application it depends on: | application:start(crypto),\napplication:start(public_key),\napplication:start(ssl),\napplication:start(hackney). | Or add hackney to the applications property of your .app in a release\n### Simple request\nDo a simple request that will return a client state: | Method = get,\nURL = <<\"https://friendpaste.com\">>,\nHeaders = [],\nPayload = <<>>,\nOptions = [],\n{ok, StatusCode, RespHeaders, ClientRef} = hackney:request(Method, URL,\n Headers, Payload,\n Options). | The request method returns the tuple `{ok, StatusCode, Headers, ClientRef}`\nor `{error, Reason}`. A `ClientRef` is simply a reference to the current\nrequest that you can reuse.\nIf you prefer the REST syntax, you can also do: | hackney:Method(URL, Headers, Payload, Options) | where `Method`, can be any HTTP method in lowercase.\n### Read the body | {ok, Body} = hackney:body(ClientRef). | `hackney:body/1` fetch the body. To fetch it by chunk you can use the\n`hackney:stream_body/1` function: | read_body(MaxLength, Ref, Acc) when MaxLength > byte_size(Acc) ->\n\tcase hackney:stream_body(Ref) of\n\t\t{ok, Data} ->\n\t\t\tread_body(MaxLength, Ref, << Acc/binary, Data/binary >>);\n\t\tdone ->\n\t\t\t{ok, Acc};\n\t\t{error, Reason} ->\n\t\t\t{error, Reason}\n\tend. | Transport = hackney_ssl,\nHost = << \"friendpaste.com\" >>,\nPort = 443,\nOptions = [],\n{ok, ConnRef} = hackney:connect(Transport, Host, Port, Options). | > To create a connection that will use an HTTP proxy use\n> `hackney_http_proxy:connect_proxy/5` instead.\n#### To get local and remote ip and port information of a connection: | > hackney:peername(ConnRef).\n> hackney:sockname(ConnRef). | #### Make a request\nOnce you created a connection use the `hackney:send_request/2` function\nto make a request: | ReqBody = << \"{\t\\\"snippet\\\": \\\"some snippet\\\" }\" >>,\nReqHeaders = [{<<\"Content-Type\">>, <<\"application/json\">>}],\nNextPath = <<\"/\">>,\nNextMethod = post,\nNextReq = {NextMethod, NextPath, ReqHeaders, ReqBody},\n{ok, _, _, ConnRef} = hackney:send_request(ConnRef, NextReq),\n{ok, Body1} = hackney:body(ConnRef). | > Note: to send a **multipart** body in a streaming fashion use the\n> `hackney:send_multipart_body/2` function.\n### Get a response asynchronously\nSince the 0.6 version, hackney is able to fetch the response\nasynchronously using the `async` option: | Method = get,\nURL = <<\"https://friendpaste.com\">>,\nHeaders = [],\nPayload = <<>>,\nOptions = [{pool, mypool}],\n{ok, StatusCode, RespHeaders, ClientRef} = hackney:request(Method, URL, Headers,\n Payload, Options). | By adding the tuple `{pool, mypool}` to the options, hackney will use\nthe connections stored in that pool. The pool gets started automatically\nthe first time it is used. You can also explicitly configure and start\nthe pool like this: | PoolName = mypool,\nOptions = [{timeout, 150000}, {max_connections, 100}],\nok = hackney_pool:start_pool(PoolName, Options), | `timeout` is the time we keep the connection alive in the pool,\n`max_connections` is the number of connections maintained in the pool. Each\nconnection in a pool is monitored and closed connections are removed\nautomatically.\nTo close a pool do: | hackney_pool:stop_pool(PoolName). | Method = get,\nURL = \"http://friendpaste.com/\",\nReqHeaders = [{<<\"accept-encoding\">>, <<\"identity\">>}],\nReqBody = <<>>,\nOptions = [{follow_redirect, true}, {max_redirect, 5}],\n{ok, S, H, Ref} = hackney:request(Method, URL, ReqHeaders,\n ReqBody, Options),\n{ok, Body1} = hackney:body(Ref). | ### Use SSL/TLS with self signed certificates\nHackney uses CA bundles adapted from Mozilla by\n[certifi](https://hex.pm/packages/certifi).\nRecognising an organisation specific (self signed) certificates is possible\nby providing the necessary `ssl_options`. Note that `ssl_options` overrides all\noptions passed to the ssl module.\nex (>= Erlang 21): | $ rebar3 update\n$ rebar3 compile | For successfully running the hackney test suite locally it is necessary to\ninstall [httpbin](https://pypi.python.org/pypi/httpbin/0.2.0).\nAn example installation using virtualenv:: | $ mkvirtualenv hackney\n$ pip install gunicorn httpbin | Running the tests: | $ gunicorn --daemon --pid httpbin.pid httpbin:app\n$ rebar3 eunit\n$ kill `cat httpbin.pid`",
"source": "/Users/hebbarp/xpress/deps/hackney/README.md"
},
"hpax": {
"definition": "",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on hpax implementation.",
"examples": "defp deps do\n [\n {:hpax, \"~> 0.1.0\"}\n ]\nend | Then, run `$ mix deps.get`.\n## Usage\nHPAX is designed to be used in both encoding and decoding scenarios. In both cases, a context is\nused to maintain state internal to the HPACK algorithm. In the common use case of using HPAX\nwithin HTTP/2, this context is called a **table** and must be shared between any\nsubsequent encoding/decoding calls within\nan endpoint. Note that the contexts used for encoding and decoding within HTTP/2 are completely\ndistinct from one another, even though they are structurally identical.\nTo encode a set of headers into a binary with HPAX: | context = HPAX.new(4096)\nheaders = [{:store, \":status\", \"201\"}, {:store, \"location\", \"http://example.com\"}]\n{encoded_headers, context} = HPAX.encode(headers, context)\n#=> {iodata, updated_context} | To decode a binary into a set of headers with HPAX: | context = HPAX.new(4096)\nencoded_headers = <<...>>\n{:ok, headers, context} = HPAX.decode(encoded_headers, context)\n#=> {:ok, [{:store, \":status\", \"201\"}, {:store, \"location\", \"http://example.com\"}], updated_context}",
"source": "/Users/hebbarp/xpress/deps/hpax/README.md"
},
"httpoison": {
"definition": "[HTTPotion](https://github.com/myfreeweb/httpotion)",
"trends": "Based on project analysis: active development with 0 key features",
"perspectives": "Open source project with community contributions. Project focuses on httpoison implementation.",
"examples": "def deps do\n [\n {:httpoison, \"~> 2.0\"}\n ]\nend | and run `$ mix deps.get`.\n## Upgrading to 2.x.x\nThe main change that caused a major version is that `ssl` option now _merges_ with the default options where previously it would override the ssl options. The new option `ssl_override` was added to allow people to keep the previous behaviour but it's more explicit now.\nThe default SSL options can be found on [hackney's codebase](https://github.com/benoitc/hackney/blob/befe2df2080704824487c3c0201417d0ddb3c686/src/hackney_connection.erl#L115-L148) as we simply use `:hackney_connections.merge_ssl_opts/2`\nMore context here: https://github.com/edgurgel/httpoison/pull/466\n## Usage | You can also easily pattern match on the `HTTPoison.Response` struct: | case HTTPoison.get(url) do\n {:ok, %HTTPoison.Response{status_code: 200, body: body}} ->\n IO.puts body\n {:ok, %HTTPoison.Response{status_code: 404}} ->\n IO.puts \"Not found :(\"\n {:error, %HTTPoison.Error{reason: reason}} ->\n IO.inspect reason\nend | [Here](https://www.erlang.org/doc/man/inet.html#posix-error-codes) is the list of all possible error reasons.\n### Options\nThere are a number of supported options(*not to be confused with the HTTP options method*), documented [here](https://hexdocs.pm/httpoison/HTTPoison.html#request/5), that can be added to your request. The example below shows the use of the `:ssl` and `:recv_timeout` options for a post request to an api that requires a bearer token. The `:ssl` option allows you to set options accepted by the [Erlang SSL module](https://erlang.org/doc/man/ssl.html), and `:recv_timeout` sets a timeout on receiving a response, the default is 5000ms. | token = \"some_token_from_another_request\"\nurl = \"https://example.com/api/endpoint_that_needs_a_bearer_token\"\nheaders = [\"Authorization\": \"Bearer #{token}\", \"Accept\": \"Application/json; Charset=utf-8\"]\noptions = [ssl: [{:versions, [:'tlsv1.2']}], recv_timeout: 500]\n{:ok, response} = HTTPoison.get(url, headers, options) | And the example below shows the use of the `:ssl` options for a post request to an api that requires a client certification. | url = \"https://example.org/api/endpoint_that_needs_client_cert\"\noptions = [ssl: [certfile: \"certs/client.crt\"]]\n{:ok, response} = HTTPoison.post(url, [], options) | ### Wrapping `HTTPoison.Base`\nYou can also use the `HTTPoison.Base` module in your modules in order to make\ncool API clients or something. The following example wraps `HTTPoison.Base` in\norder to build a client for the GitHub API\n([Poison](https://github.com/devinus/poison) is used for JSON decoding): | iex> GitHub.start\niex> GitHub.get!(\"/users/myfreeweb\").body[:public_repos]\n37 | It's possible to extend the functions listed below: | ### Async requests\nHTTPoison now comes with async requests! | iex> HTTPoison.get! \"https://github.com/\", %{}, stream_to: self\n%HTTPoison.AsyncResponse{id: #Reference<0.0.0.1654>}\niex> flush\n%HTTPoison.AsyncStatus{code: 200, id: #Reference<0.0.0.1654>}\n%HTTPoison.AsyncHeaders{headers: %{\"Connection\" => \"keep-alive\", ...}, id: #Reference<0.0.0.1654>}\n%HTTPoison.AsyncChunk{chunk: \"<!DOCTYPE html>...\", id: #Reference<0.0.0.1654>}\n%HTTPoison.AsyncEnd{id: #Reference<0.0.0.1654>}\n:ok | **Warning: this option can flood a receiver in messages.**\nIf a server may send very large messages the `async: :once` option should be used.\nThis will send only a single chunk at a time the receiver can call `HTTPoison.stream_next/1` to indicate ability to process more chunks.\n### Cookies\nHTTPoison allows you to send cookies: | iex> HTTPoison.get!(\"https://postman-echo.com/cookies\", %{}, hackney: [cookie: [\"session=a933ec1dd923b874e691; logged_in=true\"]])\n%HTTPoison.Response{\n status_code: 200,\n body: \"{\\n \\\"cookies\\\": {\\n \\\"session\\\": \\\"a933ec1dd923b874e691\\\",\